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 // Include Files
97 //-------------------------------------------------------------------------------------------------
98 // Common Definition
99 #ifdef MSOS_TYPE_LINUX_KERNEL
100 #include <linux/string.h>
101 #include <linux/slab.h>
102 #include <linux/delay.h>
103 #include <linux/sched.h>
104 #include <linux/kthread.h>
105 #include <linux/jiffies.h>
106 #include <asm/io.h>
107 #else
108 #include <stdio.h>
109 #include <string.h>
110 #include <pthread.h>
111 #endif
112
113 #include "MsCommon.h"
114 #include "MsIRQ.h"
115 #include "MsOS.h"
116 #include "MsTypes.h"
117 #include "drvSYS.h"
118 #include "halSYS.h"
119
120 // Internal Definition
121 #include "drvAUDIO.h"
122 #include "regCHIP.h"
123 #include "regAUDIO.h"
124 #include "halAUDIO.h"
125 #include "halMAD.h"
126 #include "halMAD2.h"
127 #include "halSIF.h"
128 #include "halSOUND.h"
129 #include "halAUR2.h"
130 #include "decR2_version.h"
131
132 #include "halAUDSP.h"
133
134 #if defined(MSOS_TYPE_NUTTX)
135 extern int lib_lowprintf(const char *format, ...);
136 #define DBG_PREFIX lib_lowprintf
137 #else
138 #define DBG_PREFIX printf
139 #endif
140
141 #if (defined ANDROID)
142 #include <sys/mman.h>
143 #include <cutils/ashmem.h>
144 #include <cutils/log.h>
145
146 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
147 #define LOGI ALOGI
148 #endif
149
150 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
151 #define LOGE ALOGE
152 #endif
153
154 #define HALAUDIO_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
155 #define HALAUDIO_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
156 #else
157 #ifdef CONFIG_MBOOT
158 #define HALAUDIO_PRINT(fmt, args...)
159 #define HALAUDIO_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
160 #else
161 #define HALAUDIO_PRINT(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
162 #define HALAUDIO_ERROR(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
163 #endif
164 #endif
165
166
167 //-------------------------------------------------------------------------------------------------
168 // Driver Compiler Options
169 //-------------------------------------------------------------------------------------------------
170 #define DBG_AUDIO(args...) //DBG_PREFIX(args)
171 #define DBG_AUDIO_LOAD(args...) //DBG_PREFIX(args)
172 #define DBG_AUDIO_ERROR(args...) //DBG_PREFIX(args)
173 #ifdef CONFIG_MBOOT
174 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
175 #define AUD_DBGMSG(args...)
176 #else
177 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
178 #define AUD_DBGMSG(args...) DBG_PREFIX(args)
179 #endif
180 #define HALAUDIO_CHECK_SHM_INIT \
181 do { \
182 if (g_AudioVars2 == NULL) \
183 { \
184 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
185 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
186 if (HAL_AUDIO_InitialVars() == FALSE) \
187 { \
188 MS_ASSERT(0); \
189 } \
190 } \
191 } while(0)
192
193 #ifndef MSOS_TYPE_NOS
194 void* MDrv_MPool_PA2KSEG1(void* pAddrPhys);
195 #endif
196
197 //-------------------------------------------------------------------------------------------------
198 // Local Defines
199 //-------------------------------------------------------------------------------------------------
200 #define AUDIO_HAL_ERR(x, args...) //{printf(x, ##args);}
201 #define HINIBBLE(u8Data) ((u8Data) >> 4)
202 #define LONIBBLE(u8Data) ((u8Data) << 4)
203 #if (AUDIO_R2_DMA_READER1_SUPPORT || AUDIO_R2_DMA_READER2_SUPPORT)
204 #define AUDIO_R2_DMA_RDER_CFG_REG(base, offset) ((MS_U32)(base + (offset * 2)))
205 #endif
206
207 #define HW_DMA_RDR1_BUF_UNIT 4096
208
209 #if AUDIO_HW_DMA_READER1_SUPPORT
210 #define HW_DMA_RDR1_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
211 #define HW_DMA_RDR1_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
212 #endif
213
214 #if AUDIO_HW_DMA_READER2_SUPPORT
215 #define HW_DMA_RDR2_BUF_ADDR (DSP2_HW_DMA_READER2_DRAM_BASE * BYTES_IN_MIU_LINE)
216 #define HW_DMA_RDR2_BUF_SIZE ((DSP2_HW_DMA_READER2_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
217 #endif
218
219 #if AUDIO_SW_DMA_READER1_SUPPORT
220 #define SW_DMA_RDR1_BUF_ADDR (DSP2_SW_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
221 #define SW_DMA_RDR1_BUF_SIZE ((DSP2_SW_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
222 #endif
223
224 #if AUDIO_R2_DMA_READER1_SUPPORT
225 #define R2_DMA_RDR1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA1_READER_DRAM_BASE)
226 #define R2_DMA_RDR1_BUF_SIZE MCU_R2_DMA1_READER_DRAM_SIZE
227 #endif
228
229 #if AUDIO_R2_DMA_READER2_SUPPORT
230 #define R2_DMA_RDR2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA2_READER_DRAM_BASE)
231 #define R2_DMA_RDR2_BUF_SIZE MCU_R2_DMA2_READER_DRAM_SIZE
232 #endif
233
234 #if AUDIO_PCM_CAPTURE1_SUPPORT
235 #define PCM_CAPTURE1_BUF_UNIT 128
236 #define PCM_CAPTURE1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
237 #define PCM_CAPTURE1_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
238 #endif
239
240 #if AUDIO_PCM_CAPTURE2_SUPPORT
241 #define PCM_CAPTURE2_BUF_UNIT 128
242 #define PCM_CAPTURE2_BUF_ADDR (DSP2_PCM_CAPTURE2_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
243 #define PCM_CAPTURE2_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
244 #endif
245
246 #if AUDIO_HW_DMA_WRITER1_SUPPORT
247 #define HW_DMA_WTR1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
248 #define HW_DMA_WTR1_BUF_SIZE ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE) * BYTES_IN_MIU_LINE)
249 #endif
250
251 #ifndef UNUSED
252 #define UNUSED(x) ((x)=(x))
253 #endif
254
255 #define StereoAACOutputPCM 0
256
257 //-------------------------------------------------------------------------------------------------
258 // Local Structures
259 //-------------------------------------------------------------------------------------------------
260 static MS_U8 SIF_MailBoxArray[12];
261
262 //-------------------------------------------------------------------------------------------------
263 // Global Variables
264 //-------------------------------------------------------------------------------------------------
265 AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
266 MS_U16 g_BalanceMask = 0x0000;
267 MS_BOOL g_bAudio_loadcode_from_dram = 0, g_bIsDTV;
268 MS_VIRT _gMIO_MapBase;
269 MS_S32 _s32AUDIOMutex = -1;
270 MS_S32 _s32AUDIOMutexReboot = -1;
271 MS_S32 _s32MutexLoadCode = -1;
272 MS_S32 _s32AUDIOMutexIDMA = -1;
273 MS_U8 CheckPlayDoneCnt = 0;
274 extern MS_BOOL g_bDSPLoadCode;
275 MS_U32 g_u32bDTSCD = 0x00;
276
277 extern AUDIO_SHARED_VARS2 * g_AudioVars2;
278
279 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
280 #else
281 AUDIO_SHARED_VARS2 g_audioShared;
282 #endif
283
284 #ifndef MSOS_TYPE_NUTTX
285 static MS_BOOL g_bAudioTeeInfoShmInitFlag = FALSE;
286 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
287 #else
288 AUDIO_TEE_INFO_SHARE_MEM gAudioTeeInfoShm;
289 #endif
290 AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm = NULL;
291
292 MS_BOOL g_bAudioTeeEnabled = FALSE, g_bAudioTeeMbxInitialized = FALSE;
293 MS_BOOL g_bDecDspSecureTeeAccessed = FALSE, g_bSndDspSecureTeeAccessed = FALSE;
294 #endif
295
296 //-------------------------------------------------------------------------------------------------
297 // Local Variables
298 //-------------------------------------------------------------------------------------------------
299 static MS_U32 curr_OS_Time=0;
300 static MS_S64 curr_PTS = 0;
301 static MS_BOOL g_bInitShmFlag = FALSE;
302 static MS_BOOL g_bEncodeDoneFlag = 0;
303 static MS_U8 * dma_writePtr;
304 static MS_U8 * dma_bufStartAddress;
305 static MS_U8 * dma_bufEndAddress;
306 //static MS_U8 Dvb2DecCmd_tmp;
307
308 static AUDIO_DEC_ID DTVDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
309 static AUDIO_DEC_ID HDMIDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
310 static AUDIO_DEC_ID MMDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
311 static AUDIO_DEC_ID VDDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_INVALID , AU_DEC_INVALID};
312
313 #ifdef MSOS_TYPE_NUTTX
314 static MS_S32 _s32MadEventId = -1;
315 static MS_S32 _s32MadTaskId = -1;
316 static MBX_Msg TeeToReeMbxAckMsg;
317 static MBX_Msg msg;
318 static void _MAD_Proc(void);
319 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue);
320 #endif
321
322 //mp3 encode
323 static MS_U32 MP3Encode_baseaddr = 0;
324 static MS_U32 MP3EncodeReadIndex = 0;
325 static MS_U32 MP3EncodeCopySize = 0x180; //byte
326
327 static AU_DVB_DECCMD MAD2DecCMD = AU_DVB_DECCMD_STOP;
328 static AU_DVB_DECCMD MADDec1CMD = AU_DVB_DECCMD_STOP;
329 static AU_DVB_DECCMD MADDec2CMD = AU_DVB_DECCMD_STOP;
330 static adec_type MADDec1Type = adec_type_dummy;
331 static adec_type MADDec2Type = adec_type_dummy;
332
333 MS_PHY g_pcm_capture_base_addr = 0;
334 MS_PHY g_pcm_capture2_base_addr = 0;
335
336 MS_U8 g_DSPMadMIUBank[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
337 MS_PHY g_DSPBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
338 MS_PHY g_DSPMadBaseBufferAdr[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
339 MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
340 extern MS_PHY (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
341 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
342 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
343 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
344
345 extern MS_U32 g_AudioDumpInfoCtrl;
346 extern MS_BOOL bIsNonPCMInDec2;
347 extern MS_U32 EncFrameIdx;
348 extern MS_U32 EncBuf_W_idx;
349 extern MS_U8 EncBuf_Count;
350 extern AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
351
352 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
353 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
354 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
355
356 #ifndef CONFIG_MBOOT //Add For GPL (content protection)
357 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
358 #endif //End of GPL contect protection
359
360 const MS_U32 u32PathArray[8]={0x2C64, 0x2C66, 0x2C68, 0x2C6A, 0x2C65, 0x2C67, 0x2C69, 0x2C6B};
361
362 //Refine power on sequence for earphone & DAC pop noise issue
363 const AUDIO_REG_TYPE AudioPreInitTbl_Clock[] =
364 {
365
366 //----------------AUPLL control-------------------------//Item 23
367 {0x112c9e, 0xff, 0x20}, //[15:0] 2nd order synthesizer n.f[23:8]
368 {0x112c9f, 0xff, 0x1c},
369 {0x112c9c, 0xff, 0x00}, //[7:0] 2nd order synthesizer n.f[7:0]
370 {0x112c9d, 0xff, 0xc0}, //[15] 2nd order synthesizer enable, [14] load
371 {0x112ca0, 0xff, 0x20}, //[15:0] codec synthesizer n.f << 112ca2[4] do not select codec synthesizer 1024FS clk
372 {0x112ca1, 0xff, 0x1c},
373 {0x112c9c, 0xff, 0x00},
374 {0x112c9d, 0xff, 0x80}, //[14] 2nd order synthesizer load
375 {0x112ca2, 0x08, 0x08}, //[3] Enable reference clock
376 {0x112ca2, 0x10, 0x10}, //[4] Select 1st-order or 2nd-order synthesizer
377 {0x112c70, 0xff, 0xd0}, //[1:0] AUPLL_KP0, [7:2]AUPLL_FBDIV
378 {0x112c71, 0xff, 0x12}, //[9:7] Set AUPLL_KP1_OUT = 480fs clock for SRC
379 {0x112c76, 0xff, 0x00}, //[7:0] Set AUPLL power down = 0
380 {0x112c77, 0xff, 0x03},
381
382 //----------------AUR2PLL------------------------//Item 22
383 //{0x160342, 0xff, 0x01}, //
384 //{0x160343, 0xff, 0x00}, //[8] Set AUR2PLL power down = 0
385 //{0xffffff, 0x01, 0x01}, // delay 1m sec
386
387 //---------------- Enable CLK----------------------------//Item 32
388 {0x112ca4, 0xff, 0xff}, //[10:0] CLKGEN's clock enable
389 {0x112ca5, 0xff, 0x1f},
390 {0x112cb2, 0x90, 0x90}, //[7] CLK R2 EN[3], [4] CLK PARSER EN
391 {0x112cb3, 0x60, 0x60}, //[14:13] CLK R2 EN[2:1]
392 {0x112ccb, 0x3c, 0x3c}, //[13:10] CLK DSP EN[4:1]
393 {0x163e04, 0x04, 0x04}, //[2] REG_ENABLE_CLK_PasDMA_RIU_BRG
394 {0x163e04, 0x03, 0x01}, //[1:0] REG_PasDMA_RIU_W_SEL R2
395
396 //-----------------AudioBand----------------------------//Item 21
397 {0x112b58, 0xff, 0xff}, //[15:0] DWA fix value
398 {0x112b59, 0xff, 0x01}, //[15:0] DWA fix value
399 {0x112b55, 0xf0, 0xf0}, //[15:12] DWA fix enable
400 {0x112b46, 0xff, 0x00}, //[15:0] Enable Group C
401 {0x112b47, 0xff, 0xff},
402 {0x112b56, 0xff, 0x30}, //[15:0] Enable ADC1/2
403 {0x112b57, 0xff, 0x00},
404 {0x112c6e, 0xff, 0x88}, //[7:0] Enable Grp A/B
405 {0x112b50, 0xff, 0x00}, //[15:0] DC offset value
406 {0x112b51, 0xff, 0x00},
407 {0x112b60, 0xff, 0xc0},
408 {0x112b61, 0xff, 0x38},
409 {0x112b62, 0xff, 0x38},
410 {0x112b63, 0xff, 0x38},
411 {0x112b40, 0xff, 0x4e}, //[15:0] Init CODEC SRC
412 {0x112b41, 0xff, 0x00},
413 {0x112b54, 0xff, 0x00}, //[15:0] DITHER select 0.5LSB
414 {0x112b55, 0xff, 0x01},
415 {0x112b52, 0xff, 0x00}, //[15:0] DC offset ENABLE=0, Dither ENABLE=0
416 {0x112b53, 0xff, 0x00},
417 {0x112b40, 0xff, 0x0c}, //[15:0] Init CODEC SRC
418 {0x112b41, 0xff, 0x00},
419 {0x112b54, 0x01, 0x01}, //[0] SDM EN
420
421 //-----------------SDM RESET----------------------------//Item 33
422 {0x112c00, 0xf0, 0x00},
423 {0x112c00, 0xf0, 0xf0},
424 {0x112c00, 0xf0, 0x00},
425
426 //-----------------De-POP_1-----------------------------//Item 25
427 {0x112cdc, 0xff, 0xf0}, //PD_DAC
428 {0x112cdd, 0xff, 0x3f},
429 {0x112cde, 0xff, 0x00}, //EN_CK_DAC
430 {0x112cdf, 0xff, 0x00},
431 {0x112ce6, 0xff, 0x01}, //PD_VI
432 {0x112ce7, 0xff, 0x00},
433 {0x112ce8, 0xff, 0x00}, //PD_VREF
434 {0x112ce9, 0xff, 0x80},
435 {0x112cec, 0xff, 0x10}, //PD_LDO_DAC,EN_QS_LDO_DAC
436 {0x112ced, 0xff, 0x00},
437 {0x112cee, 0xff, 0x00}, //EN_MSP
438 {0x112cef, 0xff, 0x00},
439 {0xffffff, 0x01, 0x01}, //delay 1ms
440
441 {0x112cde, 0xff, 0x00}, //EN_CK_DAC
442 {0x112cdf, 0xff, 0x08},
443 {0x112cec, 0xff, 0x08}, //PD_LDO_DAC,EN_QS_LDO_DAC
444 {0x112ced, 0xff, 0x00},
445 {0x112cee, 0xff, 0x00}, //EN_MSP
446 {0x112cef, 0xff, 0x10},
447 {0xffffff, 0x01, 0x01}, //delay 1ms
448
449 {0x112cdc, 0xff, 0x00}, //PD_DAC
450 {0x112cdd, 0xff, 0x00},
451 {0x112ce6, 0xff, 0x00}, //PD_VI
452 {0x112ce7, 0xff, 0x00},
453 {0x112ce8, 0xff, 0x00}, //PD_VREF
454 {0x112ce9, 0xff, 0x00},
455
456 {0xffffff, 0x00, 0x00}, // end of table
457 };
458
459 const AUDIO_REG_TYPE AudioInitTbl[]=
460 {
461 //-----------------De-POP_2-----------------------------//Item 26
462 {0x112cec, 0xff, 0x00}, //PD_LDO_DAC,EN_QS_LDO_DAC
463 {0x112ced, 0xff, 0x00},
464 {0x112cee, 0xff, 0x00}, //EN_MSP
465 {0x112cef, 0xff, 0x00},
466
467 //----------------Audio Reset---------------------------//Item 24
468 {0x112c00, 0xff, 0x0d},
469 {0x112c01, 0xff, 0x7f},
470 {0x112c00, 0xff, 0x0f}, //[1] CLKGEN_RESET
471 {0x112c01, 0xff, 0x7f},
472 {0x112c00, 0xff, 0x0d},
473 {0x112c01, 0xff, 0x7f},
474 {0x112c00, 0xff, 0x00},
475 {0x112c01, 0xff, 0x00},
476
477 //-----------------Synthesizer--------------------------//Item 29
478 {0x112bcf, 0x01, 0x01}, // DVB1 N.F.
479 {0x112bce, 0x01, 0x01},
480 {0x112ba8, 0xff, 0x94}, // N.f[30:16]
481 {0x112ba9, 0xff, 0x11}, // N.f[15:0]
482 {0x112baa, 0xff, 0x00},
483 {0x112bab, 0xff, 0x00},
484 {0x112c60, 0x80, 0x80},
485 {0x112bce, 0x01, 0x00},
486
487 {0x112bcf, 0x02, 0x02}, // DVB2 N.F.
488 {0x112bce, 0x02, 0x02},
489 {0x112bac, 0xff, 0x94}, // N.f[30:16]
490 {0x112bad, 0xff, 0x11},
491 {0x112bae, 0xff, 0x00},
492 {0x112baf, 0xff, 0x00},
493 {0x112c62, 0x80, 0x80},
494 {0x112bce, 0x02, 0x00},
495
496 {0x112bcf, 0x04, 0x04}, // DVB3 N.F.
497 {0x112bce, 0x04, 0x04},
498 {0x112bb0, 0xff, 0x94}, // N.f[30:16]
499 {0x112bb1, 0xff, 0x11},
500 {0x112bb2, 0xff, 0x00},
501 {0x112bb3, 0xff, 0x00},
502 {0x112c61, 0x80, 0x80},
503 {0x112bce, 0x04, 0x00},
504
505 {0x112bcf, 0x08, 0x08}, // DVB4 N.F.
506 {0x112bce, 0x08, 0x08},
507 {0x112bb4, 0xff, 0x94}, // N.f[30:16]
508 {0x112bb5, 0xff, 0x11},
509 {0x112bb6, 0xff, 0x00},
510 {0x112bb7, 0xff, 0x00},
511 {0x112c63, 0x80, 0x80},
512 {0x112bce, 0x08, 0x00},
513
514 {0x112bcf, 0x10, 0x10}, // NonPCM
515 {0x112bce, 0x20, 0x20},
516 {0x112bb8, 0xff, 0x94},
517 {0x112bb9, 0xff, 0x11},
518 {0x112bba, 0xff, 0x00},
519 {0x112bbb, 0xff, 0x00},
520 {0x112c8b, 0x40, 0x40},
521 {0x112bce, 0x20, 0x00},
522
523 {0x112bcf, 0x20, 0x20}, // NonPCM2
524 {0x112bce, 0x10, 0x10},
525 {0x112bd0, 0xff, 0x94},
526 {0x112bd1, 0xff, 0x11},
527 {0x112bd2, 0xff, 0x00},
528 {0x112bd3, 0xff, 0x00},
529 {0x112c5f, 0x40, 0x40},
530 {0x112bce, 0x10, 0x00},
531
532 {0x112bcf, 0x40, 0x40}, // NonPCM3
533 {0x112bcf, 0x80, 0x80},
534 {0x112bd6, 0xff, 0x94},
535 {0x112bd7, 0xff, 0x11},
536 {0x112bd8, 0xff, 0x00},
537 {0x112bd9, 0xff, 0x00},
538 {0x112c48, 0x80, 0x80},
539 {0x112bcf, 0x80, 0x00},
540
541 {0x112c25, 0x20, 0x20}, // DVB5 N.F.
542 {0x112c25, 0x10, 0x10},
543 {0x112c26, 0xff, 0x94},
544 {0x112c27, 0xff, 0x11},
545 {0x112c28, 0xff, 0x00},
546 {0x112c29, 0xff, 0x00},
547 {0x112c25, 0x80, 0x80},
548 {0x112c25, 0x10, 0x00},
549
550 {0x112c25, 0x02, 0x02}, // DVB6 N.F.
551 {0x112c25, 0x01, 0x01},
552 {0x112c2a, 0xff, 0x94},
553 {0x112c2b, 0xff, 0x11},
554 {0x112c2c, 0xff, 0x00},
555 {0x112c2d, 0xff, 0x00},
556 {0x112c25, 0x08, 0x08},
557 {0x112c25, 0x01, 0x00},
558
559 {0x112bcf, 0x01, 0x00}, // DVB1 is controlled by DSP/R2
560 {0x112bcf, 0x02, 0x00}, // DVB2 is controlled by DSP/R2
561 {0x112bcf, 0x04, 0x00}, // DVB3 is controlled by DSP/R2
562 {0x112bcf, 0x08, 0x00}, // DVB4 is controlled by DSP/R2
563 {0x112c25, 0x20, 0x00}, // DVB5 is controlled by DSP/R2
564 {0x112c25, 0x02, 0x00}, // DVB6 is controlled by DSP/R2
565 {0x112bcf, 0x10, 0x00}, // NonPCM1 is controlled by DSP/R2
566 {0x112bcf, 0x20, 0x00}, // NonPCM2 is controlled by DSP/R2
567 {0x112bcf, 0x40, 0x00}, // NonPCM3 is controlled by DSP/R2
568
569 //-----------------Input: HDMI (only Vivaldi side)------//Item 1
570 {0x112c44, 0xff, 0x10}, // HDMI Matrix mapping
571 {0x112c45, 0xff, 0x32}, // [1:0]/[5:4]/[9:8]/[13:12] ch1/ch2/ch3/ch4 matrix
572 {0x112c46, 0xff, 0x00}, // HDMI Matrix mapping
573 {0x112c47, 0xff, 0x00}, // [0]/[1]/[2]/[3] ch1/ch2/ch3/ch4 switch
574 {0x112c48, 0x10, 0x10}, // [4] npcm byte mode
575 {0x112c48, 0x08, 0x08}, // [3] npcm decoder PA/PB order
576 {0x112c48, 0x04, 0x00}, // [2] npcm decoder fast lock
577 {0x112c48, 0x03, 0x00}, // [1:0] npcm decoder time out SEL
578 {0x112ca4, 0x08, 0x08}, // [3:2] CLK 256fs rx/tx EN
579 {0x112ca4, 0x04, 0x04},
580
581 //-----------------Input: I2S (default slave)---------------------------//Item 2
582 {0x112c02, 0xff, 0x1f}, // [3:0] I2S/SIF/SPDIF clk EN, [4] I2S left-justified
583 {0x112c03, 0xff, 0xc0}, // [14]AUTO_CLEAR_PC_PD_BAR, [15]SPDIF_IN_BLOCK_NO_CHECK
584 {0x112cae, 0xff, 0x0e}, // [3:1] non-pcm synthesizer source SEL 432MHz
585 {0x112caf, 0xff, 0x40}, // [15:13]i2s fs synthesizer SEL source clock 432MHz
586
587 //-----------------Input: SPDIF-------------------------//Item 3
588 {0x112c0a, 0xff, 0x70},
589 {0x112c0b, 0xff, 0x13},
590
591 //-----------------Input: ADC---------------------------//Item 4
592 {0x112cda, 0xff, 0x2b},
593 {0x112cdb, 0xff, 0x03},
594 {0x112cda, 0xff, 0x28}, // [1:0]PD_ADC
595 {0x112cdb, 0xff, 0x03},
596 {0x112cf2, 0xff, 0x21}, // ADC set invert
597 {0x112cf3, 0xff, 0x0f},
598
599 //-----------------Decode Path--------------------------//Item 28
600 {0x112c60, 0xff, 0x80}, // Decoder 1 source from DVB1
601 {0x112c61, 0xff, 0x80}, // Decoder 3 source from DVB3
602 {0x112c62, 0xff, 0x80}, // Decoder 2 source from DVB2
603 {0x112c63, 0xff, 0x87}, // Decoder 4 source from SIF
604
605 //-----------------SIF init table-----------------------//Item 27/31
606 // no VIF_SIF
607
608 //-----------------Input: Channel Source----------------//Item 6
609 {0x112c64, 0xff, 0x80}, // CH1: Source0 , CH5: ADC0
610 {0x112c65, 0xff, 0x80}, // Set CH5 default source from decoder
611 {0x112c66, 0xff, 0x80}, // CH2: Source0 , CH6: Source1
612 {0x112c67, 0xff, 0x81},
613 {0x112c68, 0xff, 0x80}, // CH3: Source0 , CH7: Source3
614 {0x112c69, 0xff, 0x83},
615 {0x112c6a, 0xff, 0x80}, // CH4: Source0 , CH8: Source7
616 {0x112c6b, 0xff, 0x87},
617
618 //-----------------Output: I2S (BCK 64fs, msater)--------------------------//Item 10
619 {0x112c90, 0x40, 0x00},
620 {0x112c90, 0x1e, 0x00},
621 {0x112c8d, 0x02, 0x00},
622 {0x112c8d, 0x01, 0x00},
623 {0x112c8c, 0x70, 0x20},
624 {0x112c8c, 0x08, 0x00},
625 {0x112c8c, 0x07, 0x02},
626 {0x112c8d, 0x80, 0x80},
627 {0x112c8d, 0x40, 0x40},
628 {0x112c8d, 0x08, 0x08},
629 {0xffffff, 0x01, 0x01}, // delay 1u sec
630 {0x112c8d, 0x40, 0x00},
631 {0x112c8d, 0x08, 0x00},
632
633 //-----------------Output: SPDIF TX1--------------------//Item 11
634 {0x112c90, 0x01, 0x00},
635 {0x112c8b, 0x80, 0x80},
636 {0x112c8b, 0x20, 0x00},
637 {0x112c8b, 0x10, 0x00},
638 {0x112c8b, 0x08, 0x00},
639 {0x112c8b, 0x04, 0x00},
640 {0x112c8b, 0x02, 0x00},
641 {0x112c8b, 0x01, 0x00},
642 {0x112c8a, 0x10, 0x00},
643 {0x112c8a, 0x08, 0x00},
644 {0x112c8a, 0x04, 0x00},
645 {0x112c8a, 0x03, 0x00},
646 {0x112c8a, 0x80, 0x80},
647 {0x112c8a, 0x40, 0x40},
648 {0x112c8a, 0x20, 0x20},
649 {0xffffff, 0x01, 0x01}, // delay 1u sec
650 {0x112c8a, 0x40, 0x00},
651 {0x112c8a, 0x20, 0x00},
652 {0x112c8a, 0x90, 0x90}, // [4] EN_SPDIF_OUT_CS (referred from SPDIF_OUT_CS0~4)
653
654 //-----------------Output: DAC--------------------------//Item 12
655 {0x112cee, 0xff, 0x03},
656 {0x112cef, 0xff, 0x03},
657 {0x112cec, 0xff, 0x00},
658 {0x112ced, 0xff, 0x18},
659 {0x112b52, 0xff, 0x0f}, // DC offset EN, Dither EN
660 {0x112b53, 0xff, 0xf0},
661 {0xffffff, 0x01, 0x01}, // delay 1m sec
662 {0x112b50, 0xff, 0x10}, // fading DC offset 0x10 -> 0x20 -> 0x30 -> !K-> 0x80
663 {0x112b51, 0xff, 0x00},
664 {0xffffff, 0x01, 0x01}, // delay 1m sec
665 {0x112b50, 0xff, 0x20},
666 {0xffffff, 0x01, 0x01}, // delay 1m sec
667 {0x112b50, 0xff, 0x30},
668 {0xffffff, 0x01, 0x01}, // delay 1m sec
669 {0x112b50, 0xff, 0x40},
670 {0xffffff, 0x01, 0x01}, // delay 1m sec
671 {0x112b50, 0xff, 0x50},
672 {0xffffff, 0x01, 0x01}, // delay 1m sec
673 {0x112b50, 0xff, 0x60},
674 {0xffffff, 0x01, 0x01}, // delay 1m sec
675 {0x112b50, 0xff, 0x70},
676 {0xffffff, 0x01, 0x01}, // delay 1m sec
677 {0x112b50, 0xff, 0x80},
678 {0x112b55, 0x08, 0x00}, // [11] SDM FIX DISABLE
679
680 //-----------------Output: SPDIF TX2--------------------//Item 13
681 {0x112c5f, 0x80, 0x80},
682 {0x112c5f, 0x40, 0x40},
683 {0x112c5f, 0x20, 0x00},
684 {0x112c5f, 0x10, 0x00},
685 {0x112c5f, 0x08, 0x00},
686 {0x112c5f, 0x04, 0x00},
687 {0x112c5f, 0x02, 0x00},
688 {0x112c5f, 0x01, 0x00},
689 {0x112c5e, 0x10, 0x00},
690 {0x112c5e, 0x08, 0x00},
691 {0x112c5e, 0x04, 0x00},
692 {0x112c5e, 0x03, 0x00},
693 {0x112c5e, 0x80, 0x80},
694 {0x112c5e, 0x40, 0x40},
695 {0x112c5e, 0x20, 0x20},
696 {0xffffff, 0x01, 0x01}, // delay 1u sec
697 {0x112c5e, 0x40, 0x00},
698 {0x112c5e, 0x20, 0x00},
699 {0x112c5e, 0x90, 0x90},
700
701 //---------------------------------------------------//Item 30
702 {0x112c94, 0x01, 0x01}, // enable CH1 HW force mute, [0] ch1 mute all
703 {0x112c95, 0x01, 0x01}, // enable CH5 HW force mute, [8] ch5 mute all
704 {0x112c96, 0x01, 0x01}, // enable CH2 HW force mute, [0] ch2 mute all
705 {0x112c97, 0x01, 0x01}, // enable CH6 HW force mute, [8] ch6 mute all
706 {0x112c98, 0x01, 0x01}, // enable CH3 HW force mute, [0] ch3 mute all
707 {0x112c99, 0x01, 0x01}, // enable CH7 HW force mute, [8] ch7 mute all
708 {0x112c9a, 0x01, 0x01}, // enable CH4 HW force mute, [0] ch4 mute all
709 {0x112c9b, 0x01, 0x01}, // enable CH8 HW force mute, [8] ch8 mute all
710
711 // RD mark for not to set priority
712 //{0x112F68, 0xFF, 0x00}, //unmask high priority in local dma arbitor
713 //{0x112F88, 0xFF, 0x00}, //unmask high priority in local cache arbitor
714
715 //-----------------Interrupt--------------------------//Item 35
716 {0x112aa2, 0x60, 0x00}, //[6] IRQ2n select HDMI TX
717 {0x112aa2, 0x80, 0x80}, //[7] IRQE1 select SPDIF_TX
718
719 //-----------------MIU & DMA Setting---------------------------//Item 34
720 {0x112a44, 0xff, 0x00}, //[15] maddma fifo addr demeta
721 {0x112a45, 0xff, 0x80},
722 {0x112ac4, 0xff, 0x00}, //[15] Sedma fifo addr demeta
723 {0x112ac5, 0xff, 0x80},
724 {0x112a21, 0x04, 0x00}, //[10] maddma fifo new mode
725 {0x112aa1, 0x04, 0x00}, //[10] sedma fifo new mode(no function)
726 {0x163d03, 0x60, 0x20}, //[14:13] =01 for auR2 use MIU0, =10 for auR2 use MIU1
727 {0x163d07, 0x60, 0x20}, //[14:13] =01 for auR2_1 use MIU0, =10 for auR2_1 use MIU1
728 {0x112940, 0x20, 0x00}, //[5] enable R2 Write buffer burst mode
729 {0x163040, 0x20, 0x00}, //[5] enable R2_1 Write buffer burst mode
730 {0x112f68, 0xff, 0xff}, // dma arb
731 {0x112f69, 0xff, 0xff},
732 {0x112f66, 0xff, 0x00}, // dma arb
733 {0x112f67, 0xff, 0x00},
734 {0x112f64, 0xff, 0x00}, // dma arb
735 {0x112f65, 0xff, 0x04},
736 {0x112f62, 0xff, 0x08}, // dma arb
737 {0x112f63, 0xff, 0x20},
738 {0x112f60, 0xff, 0x15}, // dma arb
739 {0x112f61, 0xff, 0x80},
740 {0x112f88, 0xff, 0xff}, // cache arb
741 {0x112f89, 0xff, 0xff},
742 {0x112f86, 0xff, 0x00}, // cache arb
743 {0x112f87, 0xff, 0x00},
744 {0x112f84, 0xff, 0x00}, // cache arb
745 {0x112f85, 0xff, 0x04},
746 {0x112f82, 0xff, 0x08}, // cache arb
747 {0x112f83, 0xff, 0x20},
748 {0x112f80, 0xff, 0x15}, // cache arb
749 {0x112f81, 0xff, 0x80},
750 {0x163d88, 0xff, 0xff}, // R2 arb
751 {0x163d89, 0xff, 0xff},
752 {0x163d86, 0xff, 0x00}, // R2 arb
753 {0x163d87, 0xff, 0x00},
754 {0x163d84, 0xff, 0x00}, // R2 arb
755 {0x163d85, 0xff, 0x04},
756 {0x163d82, 0xff, 0x08}, // R2 arb
757 {0x163d83, 0xff, 0x20},
758 {0x163d80, 0xff, 0x15}, // R2 arb
759 {0x163d81, 0xff, 0x80},
760 {0x163da8, 0xff, 0xff}, // R2_1 arb
761 {0x163da9, 0xff, 0xff},
762 {0x163da6, 0xff, 0x00}, // R2_1 arb
763 {0x163da7, 0xff, 0x00},
764 {0x163da4, 0xff, 0x00}, // R2_1 arb
765 {0x163da5, 0xff, 0x04},
766 {0x163da2, 0xff, 0x08}, // R2_1 arb
767 {0x163da3, 0xff, 0x20},
768 {0x163da0, 0xff, 0x15}, // R2_1 arb
769 {0x163da1, 0xff, 0x80},
770 {0x163e28, 0xff, 0xff}, // dma_l2 arb
771 {0x163e29, 0xff, 0xff},
772 {0x163e26, 0xff, 0x00}, // dma_l2 arb
773 {0x163e27, 0xff, 0x00},
774 {0x163e24, 0xff, 0x00}, // dma_l2 arb
775 {0x163e25, 0xff, 0x04},
776 {0x163e22, 0xff, 0x08}, // dma_l2 arb
777 {0x163e23, 0xff, 0x20},
778 {0x163e20, 0xff, 0x15}, // dma_l2 arb
779 {0x163e21, 0xff, 0x80},
780
781 //----------------- DFS ---------------------------//Item 36
782 {0x163c61, 0x03, 0x02}, //[9:8] CLK DSP DFS SEL[1:0] = MPLL432
783 {0x163c61, 0x10, 0x00}, //[12] CLK DSP DFS SEL[2] = 0
784 {0x163c61, 0x08, 0x08}, //[11] CLK DSP DFS EN
785 {0x163c60, 0x1f, 0x1a}, //[4:0] DSP DFS DIV
786 {0x163c60, 0x40, 0x40}, //[6] DSP DFS EN
787 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
788 {0x163c60, 0x80, 0x80}, //[7] DSP DFS UPDATE
789 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
790 {0x163c63, 0x03, 0x02}, //[9:8] CLK R2 DFS SEL[1:0] = MPLL432
791 {0x163c63, 0x10, 0x00}, //[12] CLK R2 DFS SEL[2] = 0
792 {0x163c63, 0x08, 0x08}, //[11] CLK R2 DFS EN
793 {0x163c62, 0x1f, 0x1f}, //[4:0] R2 DFS DIV
794 {0x163c62, 0x40, 0x40}, //[6] R2 DFS EN
795 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
796 {0x163c62, 0x80, 0x80}, //[7] R2 DFS UPDATE
797 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
798
799 //----------------------------------------------------
800 //MCM off and Adress limiter bypass
801 //----------------------------------------------------
802 {0x163ca0, 0x20, 0x20},
803 {0x163ca1, 0x20, 0x20},
804 {0x163cc0, 0x20, 0x20},
805 {0x163cc1, 0x20, 0x20},
806 {0x163d40, 0x20, 0x20},
807 {0x163d41, 0x20, 0x20},
808 {0x163cb1, 0x20, 0x20},
809 {0x163cd1, 0x20, 0x20},
810 {0x163c30, 0x20, 0x20},
811 {0x163c31, 0x20, 0x20},
812 {0x163e06, 0xFF, 0x00},
813
814 // ----------------------------------------------------
815 // sound effect init settings
816 //-----------------------------------------------------
817 {0x112D01, 0xFF, 0x8C}, // AUOUT0 volume : 0dB ; Mute @@VVV
818 {0x112D03, 0xFF, 0x8C}, // AUOUT1 volume : 0dB ; Mute @@VVV
819 {0x112D05, 0xFF, 0x8C}, // AUOUT2 volume : 0dB ; Mute @@VVV
820 {0x112D07, 0xFF, 0x8C}, // AUOUT3 volume : 0dB ; Mute @@VVV
821 {0x112D09, 0xFF, 0x8C}, // I2S_OUT volume : 0dB ; Mute @@VVV
822 {0x112D0B, 0xFF, 0x0C}, // SPDIF_OUT volume : 0dB ; UnMute @@VVV
823 // if spdif change to mute, need set g_SPDIF_MuteStatus = 1;
824 {0x112D0F, 0xFF, 0x0C}, // HDMI_OUT volume : 0dB ; UnMute @@VVV
825
826 {0x112D20, 0x80, 0x00}, // Disable EQ @@VVV
827 {0x112D21, 0xFF, 0xC8}, // Enable Sound effect & tone @@VVV
828 {0x112D22, 0x3F, 0x3F}, // Enable all output Volume control @@VVV
829 {0x112D23, 0x01, 0x01}, // Enable SPDIF_OUT volume control @@VVV
830 {0x112D31, 0x02, 0x00}, // disable SE-DSP power-down command @@VVV
831
832 {0x112D50, 0xFF, 0xFF}, // DAC0/1 source default in NULL path @@VVV
833 {0x112D51, 0xFF, 0xFF}, // DAC2/3 source default in NULL path @@VVV
834 {0x112D52, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
835 {0x112D53, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
836 {0x112D54, 0xF0, 0x40}, // SRC source from PCM @@VVV
837
838 {0x112D5D, 0xFF, 0x0C}, // set mix volume of CH5, CH6, CH8 to 0dB
839 {0x112D5C, 0xFF, 0x00},
840 {0x112D5F, 0xFF, 0x0C},
841 {0x112D5E, 0xFF, 0x00},
842 {0x112D5B, 0xFF, 0x0C},
843 {0x112D5A, 0xFF, 0x00},
844 {0x16038B, 0x08, 0x08}, // enable WFI mode
845
846 {0x112DC0, 0xFF, 0xB5}, //DSP clock = 364.5Mhz
847 {0x112DC1, 0xFF, 0x00}, //DSP Time Constant = (364.5/2 - 1) = 181 = 0x00B5
848
849 {0xFFFFFF, 0x00, 0x00}, // end of table
850 };
851
852 const AUDIO_REG_TYPE2 ResetDMIOTbl[]=
853 {
854
855 //DMIO a0xx reset
856
857 {0x112a80, 0xffff, 0x0040},
858 {0x112a80, 0xffff, 0x0043},
859 {0x112a84, 0xffff, 0xa05a},
860 {0x112a82, 0xffff, 0x0000},
861 {0x112a82, 0xffff, 0x0080},
862 {0x112a80, 0xffff, 0x0053},
863 {0x112a80, 0xffff, 0x0043},
864 {0x112a84, 0xffff, 0xa05e},
865 {0x112a82, 0xffff, 0x0000},
866 {0x112a82, 0xffff, 0x0080},
867 {0x112a80, 0xffff, 0x0053},
868 {0x112a80, 0xffff, 0x0043},
869 {0x112a84, 0xffff, 0xa062},
870 {0x112a82, 0xffff, 0x0000},
871 {0x112a82, 0xffff, 0x0080},
872 {0x112a80, 0xffff, 0x0053},
873 {0x112a80, 0xffff, 0x0043},
874 {0x112a84, 0xffff, 0xa066},
875 {0x112a82, 0xffff, 0x0000},
876 {0x112a82, 0xffff, 0x0080},
877 {0x112a80, 0xffff, 0x0053},
878 {0x112a80, 0xffff, 0x0043},
879 {0x112a84, 0xffff, 0xa06a},
880 {0x112a82, 0xffff, 0x0000},
881 {0x112a82, 0xffff, 0x0080},
882 {0x112a80, 0xffff, 0x0053},
883 {0x112a80, 0xffff, 0x0043},
884 {0x112a84, 0xffff, 0xa06e},
885 {0x112a82, 0xffff, 0x0000},
886 {0x112a82, 0xffff, 0x0080},
887 {0x112a80, 0xffff, 0x0053},
888 {0x112a80, 0xffff, 0x0043},
889 {0x112a84, 0xffff, 0xa072},
890 {0x112a82, 0xffff, 0x0000},
891 {0x112a82, 0xffff, 0x0080},
892 {0x112a80, 0xffff, 0x0053},
893 {0x112a80, 0xffff, 0x0043},
894 {0x112a84, 0xffff, 0xa076},
895 {0x112a82, 0xffff, 0x0000},
896 {0x112a82, 0xffff, 0x0080},
897 {0x112a80, 0xffff, 0x0053},
898 {0x112a80, 0xffff, 0x0043},
899 {0x112a84, 0xffff, 0xa076},
900 {0x112a82, 0xffff, 0x0000},
901 {0x112a82, 0xffff, 0x0080},
902 {0x112a80, 0xffff, 0x0053},
903 {0x112a80, 0xffff, 0x0043},
904 {0x112a84, 0xffff, 0xa07a},
905 {0x112a82, 0xffff, 0x0000},
906 {0x112a82, 0xffff, 0x0080},
907 {0x112a80, 0xffff, 0x0053},
908 {0x112a80, 0xffff, 0x0043},
909 {0x112a84, 0xffff, 0xa07e},
910 {0x112a82, 0xffff, 0x0000},
911 {0x112a82, 0xffff, 0x0080},
912 {0x112a80, 0xffff, 0x0053},
913 {0x112a80, 0xffff, 0x0043},
914 {0x112a84, 0xffff, 0xa082},
915 {0x112a82, 0xffff, 0x0000},
916 {0x112a82, 0xffff, 0x0080},
917 {0x112a80, 0xffff, 0x0053},
918 {0x112a80, 0xffff, 0x0043},
919 {0x112a84, 0xffff, 0xa086},
920 {0x112a82, 0xffff, 0x0000},
921 {0x112a82, 0xffff, 0x0080},
922 {0x112a80, 0xffff, 0x0053},
923 {0x112a80, 0xffff, 0x0043},
924 {0x112a84, 0xffff, 0xa08a},
925 {0x112a82, 0xffff, 0x0000},
926 {0x112a82, 0xffff, 0x0080},
927 {0x112a80, 0xffff, 0x0053},
928 {0x112a80, 0xffff, 0x0043},
929 {0x112a84, 0xffff, 0xa0b5},
930 {0x112a82, 0xffff, 0x0000},
931 {0x112a82, 0xffff, 0x0080},
932 {0x112a80, 0xffff, 0x0053},
933 {0x112a80, 0xffff, 0x0043},
934 {0x112a84, 0xffff, 0xa0e0},
935 {0x112a82, 0xffff, 0x0000},
936 {0x112a82, 0xffff, 0x0080},
937
938 {0x112a80, 0xffff, 0x0053},
939 {0x112a80, 0xffff, 0x0043},
940 {0x112a84, 0xffff, 0xa17a},
941 {0x112a82, 0xffff, 0x0000},
942 {0x112a82, 0xffff, 0x0080},
943 {0x112a80, 0xffff, 0x0053},
944 {0x112a80, 0xffff, 0x0043},
945 {0x112a84, 0xffff, 0xa17e},
946 {0x112a82, 0xffff, 0x0000},
947 {0x112a82, 0xffff, 0x0080},
948 {0x112a80, 0xffff, 0x0053},
949 {0x112a80, 0xffff, 0x0043},
950 {0x112a84, 0xffff, 0xa182},
951 {0x112a82, 0xffff, 0x0000},
952 {0x112a82, 0xffff, 0x0080},
953 {0x112a80, 0xffff, 0x0053},
954 {0x112a80, 0xffff, 0x0043},
955 {0x112a84, 0xffff, 0xa186},
956 {0x112a82, 0xffff, 0x0000},
957 {0x112a82, 0xffff, 0x0080},
958 {0x112a80, 0xffff, 0x0053},
959 {0x112a80, 0xffff, 0x0043},
960 {0x112a84, 0xffff, 0xa18a},
961 {0x112a82, 0xffff, 0x0000},
962 {0x112a82, 0xffff, 0x0080},
963 {0x112a80, 0xffff, 0x0053},
964 {0x112a80, 0xffff, 0x0043},
965 {0x112a84, 0xffff, 0xa176},
966 {0x112a82, 0xffff, 0x0000},
967 {0x112a82, 0xffff, 0x0080},
968 {0x112a80, 0xffff, 0x0053},
969 {0x112a80, 0xffff, 0x0043},
970 {0x112a84, 0xffff, 0xa1e0},
971 {0x112a82, 0xffff, 0x0000},
972 {0x112a82, 0xffff, 0x0080},
973 {0x112a80, 0xffff, 0x0053},
974 {0x112a80, 0xffff, 0x0043},
975 {0x112a84, 0xffff, 0xa1e8},
976 {0x112a82, 0xffff, 0x0000},
977 {0x112a82, 0xffff, 0x0080},
978 {0x112a80, 0xffff, 0x0053},
979 {0x112a80, 0xffff, 0x0043},
980 {0x112a80, 0xffff, 0x0000},
981 {0x112c00, 0xffff, 0x0101},
982 {0x112c00, 0xffff, 0x0000},
983 {0x112c58, 0x0006, 0x0006}, //SPDIF HDMI Decemational mode on
984
985 //end DMIO a0xx reset
986 {0xffffff, 0x0000, 0x0000}, // end of table
987 };
988
989 const AUDIO_REG_TYPE AudioAUSDMTbl_On[] =
990 {
991 {0x112CDC, 0xFF, 0x00},
992 {0x112CDD, 0xFF, 0x00},
993 {0x112CDE, 0xFF, 0x00},
994 {0x112CDF, 0xFF, 0x08},
995 {0x112CE6, 0xFF, 0x00},
996 {0x112CE7, 0xFF, 0x00},
997 {0x112CE8, 0xFF, 0x00},
998 {0x112CE9, 0xFF, 0x00},
999 {0x112CEC, 0xFF, 0x00},
1000 {0x112CED, 0xFF, 0x00},
1001 {0x112CEE, 0xFF, 0x00},
1002 {0x112CEF, 0xFF, 0x00},
1003 //end DMIO a0xx reset
1004 {0xffffff, 0x0000, 0x0000}, // end of table
1005 };
1006
1007 const AUDIO_REG_TYPE AudioAUSDMTbl_Off[] =
1008 {
1009 {0x112CDC, 0xFF, 0x00},
1010 {0x112CDD, 0xFF, 0x3F},
1011 {0x112CDE, 0xFF, 0x00},
1012 {0x112CDF, 0xFF, 0x00},
1013 {0x112CE6, 0xFF, 0x01},
1014 {0x112CE7, 0xFF, 0x00},
1015 {0x112CE8, 0xFF, 0x00},
1016 {0x112CE9, 0xFF, 0x80},
1017 {0x112CEC, 0xFF, 0x10},
1018 {0x112CED, 0xFF, 0x00},
1019 {0x112CEE, 0xFF, 0x00},
1020 {0x112CEF, 0xFF, 0x00},
1021 //end DMIO a0xx reset
1022 {0xffffff, 0x0000, 0x0000}, // end of table
1023 };
1024
1025 const AUDIO_REG_TYPE Audio_stopDecTbl[] =
1026 {
1027 {0x160399 , 0xFF, 0x00}, // DEC R2(2R)
1028 {0x16039b , 0xFF, 0x00},
1029 {0x112e99 , 0xFF, 0x00}, // DEC R2(1R)
1030 {0x112e9b , 0xFF, 0x00},
1031 {0x112a2c , 0xFF, 0x00}, // DEC DSP
1032 {0x112aac , 0xFF, 0x00}, // SE DSP
1033
1034 {0xFFFFFF , 0x00, 0x00}, // end of table
1035 };
1036
1037 #if AUDIO_HW_DMA_READER1_SUPPORT
1038 AUDIO_PCM_t Audio_Pcm_HwDma_Reader1 = {
1039 .u8Name = AUDIO_HW_DMA_READER1,
1040 .tPcmOps = {
1041 .open = HAL_AUDIO_PCM_HwDma_Reader1_Open,
1042 .close = HAL_AUDIO_PCM_HwDma_Reader1_Close,
1043 .start = HAL_AUDIO_PCM_HwDma_Reader1_Start,
1044 .stop = HAL_AUDIO_PCM_HwDma_Reader1_Stop,
1045 .set = HAL_AUDIO_PCM_HwDma_Reader1_Set,
1046 .get = HAL_AUDIO_PCM_HwDma_Reader1_Get,
1047 .read = NULL,
1048 .write = HAL_AUDIO_PCM_HwDma_Reader1_Write,
1049 .flush = HAL_AUDIO_PCM_HwDma_Reader1_Flush,
1050 },
1051 .tPcmCaps = {
1052 .u8MultiChFlag = FALSE,
1053 .u8MixingFlag = FALSE,
1054 .u8CaptureFlag = FALSE,
1055 .u32Channel = {1, 2},
1056 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1057 .u32BitWidth = {16},
1058 },
1059 };
1060 #endif
1061
1062 #if AUDIO_HW_DMA_READER2_SUPPORT
1063 AUDIO_PCM_t Audio_Pcm_HwDma_Reader2 = {
1064 .u8Name = AUDIO_HW_DMA_READER2,
1065 .tPcmOps = {
1066 .open = HAL_AUDIO_PCM_HwDma_Reader2_Open,
1067 .close = HAL_AUDIO_PCM_HwDma_Reader2_Close,
1068 .start = HAL_AUDIO_PCM_HwDma_Reader2_Start,
1069 .stop = HAL_AUDIO_PCM_HwDma_Reader2_Stop,
1070 .set = HAL_AUDIO_PCM_HwDma_Reader2_Set,
1071 .get = HAL_AUDIO_PCM_HwDma_Reader2_Get,
1072 .read = NULL,
1073 .write = HAL_AUDIO_PCM_HwDma_Reader2_Write,
1074 .flush = HAL_AUDIO_PCM_HwDma_Reader2_Flush,
1075 },
1076 .tPcmCaps = {
1077 .u8MultiChFlag = FALSE,
1078 .u8MixingFlag = FALSE,
1079 .u8CaptureFlag = FALSE,
1080 .u32Channel = {1, 2},
1081 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1082 .u32BitWidth = {16},
1083 },
1084 };
1085 #endif
1086
1087 #if AUDIO_SW_DMA_READER1_SUPPORT
1088 AUDIO_PCM_t Audio_Pcm_SwDma_Reader1 = {
1089 .u8Name = AUDIO_SW_DMA_READER1,
1090 .tPcmOps = {
1091 .open = HAL_AUDIO_PCM_SwDma_Reader1_Open,
1092 .close = HAL_AUDIO_PCM_SwDma_Reader1_Close,
1093 .start = HAL_AUDIO_PCM_SwDma_Reader1_Start,
1094 .stop = HAL_AUDIO_PCM_SwDma_Reader1_Stop,
1095 .set = HAL_AUDIO_PCM_SwDma_Reader1_Set,
1096 .get = HAL_AUDIO_PCM_SwDma_Reader1_Get,
1097 .read = NULL,
1098 .write = HAL_AUDIO_PCM_SwDma_Reader1_Write,
1099 .flush = HAL_AUDIO_PCM_SwDma_Reader1_Flush,
1100 },
1101 .tPcmCaps = {
1102 .u8MultiChFlag = FALSE,
1103 .u8MixingFlag = FALSE,
1104 .u8CaptureFlag = FALSE,
1105 .u32Channel = {1, 2},
1106 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
1107 .u32BitWidth = {16},
1108 },
1109 };
1110 #endif
1111
1112 #if AUDIO_R2_DMA_READER1_SUPPORT
1113 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader1 = {
1114 .u8Name = AUDIO_R2_DMA_READER1,
1115 .tPcmOps = {
1116 .open = HAL_AUDIO_PCM_R2Dma_Reader1_Open,
1117 .close = HAL_AUDIO_PCM_R2Dma_Reader1_Close,
1118 .start = HAL_AUDIO_PCM_R2Dma_Reader1_Start,
1119 .stop = HAL_AUDIO_PCM_R2Dma_Reader1_Stop,
1120 .set = HAL_AUDIO_PCM_R2Dma_Reader1_Set,
1121 .get = HAL_AUDIO_PCM_R2Dma_Reader1_Get,
1122 .read = NULL,
1123 .write = HAL_AUDIO_PCM_R2Dma_Reader1_Write,
1124 .flush = HAL_AUDIO_PCM_R2Dma_Reader1_Flush,
1125 },
1126 .tPcmCaps = {
1127 .u8MultiChFlag = TRUE,
1128 .u8MixingFlag = FALSE,
1129 .u8CaptureFlag = FALSE,
1130 .u32Channel = {1, 2, 10},
1131 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1132 .u32BitWidth = {16},
1133 },
1134 };
1135 #endif
1136
1137 #if AUDIO_R2_DMA_READER2_SUPPORT
1138 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader2 = {
1139 .u8Name = AUDIO_R2_DMA_READER2,
1140 .tPcmOps = {
1141 .open = HAL_AUDIO_PCM_R2Dma_Reader2_Open,
1142 .close = HAL_AUDIO_PCM_R2Dma_Reader2_Close,
1143 .start = HAL_AUDIO_PCM_R2Dma_Reader2_Start,
1144 .stop = HAL_AUDIO_PCM_R2Dma_Reader2_Stop,
1145 .set = HAL_AUDIO_PCM_R2Dma_Reader2_Set,
1146 .get = HAL_AUDIO_PCM_R2Dma_Reader2_Get,
1147 .read = NULL,
1148 .write = HAL_AUDIO_PCM_R2Dma_Reader2_Write,
1149 .flush = HAL_AUDIO_PCM_R2Dma_Reader2_Flush,
1150 },
1151 .tPcmCaps = {
1152 .u8MultiChFlag = TRUE,
1153 .u8MixingFlag = FALSE,
1154 .u8CaptureFlag = FALSE,
1155 .u32Channel = {1, 2, 10},
1156 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1157 .u32BitWidth = {16},
1158 },
1159 };
1160 #endif
1161
1162 #if AUDIO_PCM_CAPTURE1_SUPPORT
1163 AUDIO_PCM_t Audio_Pcm_Capture1 = {
1164 .u8Name = AUDIO_PCM_CAPTURE1,
1165 .tPcmOps = {
1166 .open = HAL_AUDIO_PCM_Capture1_Open,
1167 .close = HAL_AUDIO_PCM_Capture1_Close,
1168 .start = HAL_AUDIO_PCM_Capture1_Start,
1169 .stop = HAL_AUDIO_PCM_Capture1_Stop,
1170 .set = HAL_AUDIO_PCM_Capture1_Set,
1171 .get = HAL_AUDIO_PCM_Capture1_Get,
1172 .read = HAL_AUDIO_PCM_Capture1_Read,
1173 .write = NULL,
1174 .flush = HAL_AUDIO_PCM_Capture1_Flush,
1175 },
1176 .tPcmCaps = {
1177 .u8MultiChFlag = FALSE,
1178 .u8MixingFlag = FALSE,
1179 .u8CaptureFlag = TRUE,
1180 .u32Channel = {2},
1181 .u32SampleRate = {48000},
1182 .u32BitWidth = {16},
1183 },
1184 };
1185 #endif
1186
1187 #if AUDIO_PCM_CAPTURE2_SUPPORT
1188 AUDIO_PCM_t Audio_Pcm_Capture2 = {
1189 .u8Name = AUDIO_PCM_CAPTURE2,
1190 .tPcmOps = {
1191 .open = HAL_AUDIO_PCM_Capture2_Open,
1192 .close = HAL_AUDIO_PCM_Capture2_Close,
1193 .start = HAL_AUDIO_PCM_Capture2_Start,
1194 .stop = HAL_AUDIO_PCM_Capture2_Stop,
1195 .set = HAL_AUDIO_PCM_Capture2_Set,
1196 .get = HAL_AUDIO_PCM_Capture2_Get,
1197 .read = HAL_AUDIO_PCM_Capture2_Read,
1198 .write = NULL,
1199 .flush = HAL_AUDIO_PCM_Capture2_Flush,
1200 },
1201 .tPcmCaps = {
1202 .u8MultiChFlag = FALSE,
1203 .u8MixingFlag = FALSE,
1204 .u8CaptureFlag = TRUE,
1205 .u32Channel = {2},
1206 .u32SampleRate = {48000},
1207 .u32BitWidth = {16},
1208 },
1209 };
1210 #endif
1211
1212 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1213 AUDIO_PCM_t Audio_Pcm_HwDma_Writer1 = {
1214 .u8Name = AUDIO_HW_DMA_WRITER1,
1215 .tPcmOps = {
1216 .open = HAL_AUDIO_PCM_HwDma_Writer1_Open,
1217 .close = HAL_AUDIO_PCM_HwDma_Writer1_Close,
1218 .start = HAL_AUDIO_PCM_HwDma_Writer1_Start,
1219 .stop = HAL_AUDIO_PCM_HwDma_Writer1_Stop,
1220 .set = HAL_AUDIO_PCM_HwDma_Writer1_Set,
1221 .get = HAL_AUDIO_PCM_HwDma_Writer1_Get,
1222 .read = HAL_AUDIO_PCM_HwDma_Writer1_Read,
1223 .write = NULL,
1224 .flush = HAL_AUDIO_PCM_HwDma_Writer1_Flush,
1225 },
1226 .tPcmCaps = {
1227 .u8MultiChFlag = FALSE,
1228 .u8MixingFlag = FALSE,
1229 .u8CaptureFlag = TRUE,
1230 .u32Channel = {2},
1231 .u32SampleRate = {48000},
1232 .u32BitWidth = {16},
1233 },
1234 };
1235 #endif
1236
1237 MS_U8 g_Common_PCM_IO_Init = FALSE;
1238
1239 AUDIO_PCM_t *g_PCM[AUDIO_PCM_MAXNUM] = {
1240 #if AUDIO_HW_DMA_READER1_SUPPORT
1241 &Audio_Pcm_HwDma_Reader1,
1242 #endif
1243 #if AUDIO_HW_DMA_READER2_SUPPORT
1244 &Audio_Pcm_HwDma_Reader2,
1245 #endif
1246 #if AUDIO_SW_DMA_READER1_SUPPORT
1247 &Audio_Pcm_SwDma_Reader1,
1248 #endif
1249 #if AUDIO_R2_DMA_READER1_SUPPORT
1250 &Audio_Pcm_R2Dma_Reader1,
1251 #endif
1252 #if AUDIO_R2_DMA_READER2_SUPPORT
1253 &Audio_Pcm_R2Dma_Reader2,
1254 #endif
1255 #if AUDIO_PCM_CAPTURE1_SUPPORT
1256 &Audio_Pcm_Capture1,
1257 #endif
1258 #if AUDIO_PCM_CAPTURE2_SUPPORT
1259 &Audio_Pcm_Capture2,
1260 #endif
1261 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1262 &Audio_Pcm_HwDma_Writer1,
1263 #endif
1264 };
1265
1266
1267 //-------------------------------------------------------------------------------------------------
1268 // Debug Functions
1269 //-------------------------------------------------------------------------------------------------
1270
1271 //-------------------------------------------------------------------------------------------------
1272 // Local Functions
1273 //-------------------------------------------------------------------------------------------------
1274
1275 ////////////////////////////////////////////////////////////////////////////////
1276 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus()
1277 /// @brief \b Function \b Description: Return audio status.
1278 /// @return MS_U16 \b : return structure which include pcm, non pcm, sampling rate.
1279 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus(ST_HDMI_AUDIO_STATUS * p_hdmiAudioSts)1280 MS_BOOL HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus( ST_HDMI_AUDIO_STATUS *p_hdmiAudioSts)
1281 {
1282 MS_BOOL ret = true;
1283
1284 if (HAL_AUDIO_HDMI_NonpcmMonitor())
1285 {
1286 switch(HAL_AUDIO_HDMI_DolbyMonitor())
1287 {
1288 case 0x01: p_hdmiAudioSts->audio_type = HDMI_RX_DD; break;
1289 case 0x0b: p_hdmiAudioSts->audio_type = HDMI_RX_DTS; break;
1290 case 0x15: p_hdmiAudioSts->audio_type = HDMI_RX_DDP; break;
1291 default: p_hdmiAudioSts->audio_type = HDMI_RX_Other; break;
1292 }
1293 }
1294 else
1295 p_hdmiAudioSts->audio_type = HDMI_RX_PCM;
1296
1297 return ret;
1298
1299 }
1300
HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)1301 MS_BOOL HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)
1302 {
1303 MS_U8 i = 0;
1304 MS_U8 array_mount = 0;
1305
1306 if (pAUDIOShared == NULL)
1307 {
1308 return FALSE;
1309 }
1310
1311 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1312
1313 /* Fill in default value */
1314 pAUDIOShared->g_DspCodeType = AU_DVB_STANDARD_INVALID;
1315 pAUDIOShared->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
1316 pAUDIOShared->g_u8MADSkipResetFlag = FALSE;
1317 pAUDIOShared->g_u8MAD2SkipResetFlag = FALSE;
1318 pAUDIOShared->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
1319 pAUDIOShared->g_u8DspAliveFlag = TRUE;
1320 pAUDIOShared->g_eSpdifOutputType = SPDIF_OUT_NONE;
1321 pAUDIOShared->g_u8SifDspType = DSP_SE;
1322
1323 pAUDIOShared->g_dolbyDrcMode = RF_MODE;
1324 array_mount = sizeof(pAUDIOShared->sif_gain_0) / sizeof(pAUDIOShared->sif_gain_0[0]);
1325 for (i = 0; i < array_mount; i++)
1326 {
1327 /* Note! sif_gain_0[] is expected same length as sif_shift_0[] */
1328 pAUDIOShared->sif_gain_0[i] = 0x7FFF;
1329 pAUDIOShared->sif_shift_0[i] = 0x0000;
1330 }
1331 pAUDIOShared->g_u8IntTag = 1;
1332 pAUDIOShared->int_mb_cnt = 0;
1333
1334 pAUDIOShared->CompressInfo = 0;
1335 for ( i = 0; i < MAX_AUDIO_BASE_ADDRESS_NUM2; i++ )
1336 {
1337 pAUDIOShared->g_DSPMadMIUBank[i] = g_DSPMadMIUBank[i];
1338 pAUDIOShared->g_DSPBinBaseAddress[i] = g_DSPBinBaseAddress[i];
1339 pAUDIOShared->g_DSPMadBaseBufferAdr[i] = g_DSPMadBaseBufferAdr[i];
1340 pAUDIOShared->g_DSPDDRBinBaseAddress[i] = g_DSPDDRBinBaseAddress[i];
1341 }
1342
1343 pAUDIOShared->eMainSourceType = E_AUDIO_INFO_DTV_IN;
1344 pAUDIOShared->ePrevSourceType = E_AUDIO_INFO_DTV_IN;
1345 for ( i = 0; i < AU_DEC_MAX; i++ )
1346 {
1347 pAUDIOShared->DspUsage[i].bDecInUsed = FALSE;
1348 pAUDIOShared->DspUsage[i].eAudioType = Audio_DEC_NULL;
1349 pAUDIOShared->DspUsage[i].eUsageType = AUDIO_USAGE_TYPE_NONE;
1350 }
1351
1352 pAUDIOShared->eAudioSource = E_AUDIO_INFO_ADC_IN;
1353 pAUDIOShared->eMainAudioSource = AUDIO_NULL_INPUT;
1354 pAUDIOShared->eSubAudioSource = AUDIO_NULL_INPUT;
1355 pAUDIOShared->eScartAudioSource = AUDIO_NULL_INPUT;
1356
1357 /* 1st decoder (depends on chip) */
1358 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsVersion = AUD_CAP_VERSION;
1359 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1360 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum = 2;
1361 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDmaReaderNum = 2;
1362 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsADSupported = TRUE;
1363 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsPusiDetectSupported = FALSE;
1364 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMpegSupported = TRUE;
1365 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3Supported = TRUE;
1366 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3pSupported = TRUE;
1367 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAacSupported = TRUE;
1368 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMp3Supported = TRUE;
1369 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaSupported = TRUE;
1370 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsRa8LbrSupported = TRUE;
1371 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsXpcmSupported = TRUE;
1372 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsSupported = TRUE;
1373 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaProSupported = TRUE;
1374 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsFlacSupported = TRUE;
1375 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsVorbisSupported = TRUE;
1376 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsLbrSupported = TRUE;
1377 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrNbSupported = TRUE;
1378 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrWbSupported = TRUE;
1379 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDraSupported = TRUE;
1380
1381 /* 2nd decoder (depends on chip) */
1382 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsVersion = AUD_CAP_VERSION;
1383 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1384 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDecoderNum = 2;
1385 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDmaReaderNum = 2;
1386 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsADSupported = TRUE;
1387 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsPusiDetectSupported = FALSE;
1388 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMpegSupported = TRUE;
1389 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3Supported = TRUE;
1390 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3pSupported = TRUE;
1391 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAacSupported = TRUE;
1392 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMp3Supported = TRUE;
1393 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaSupported = TRUE;
1394 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsRa8LbrSupported = TRUE;
1395 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsXpcmSupported = TRUE;
1396 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsSupported = TRUE;
1397 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaProSupported = TRUE;
1398 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsFlacSupported = TRUE;
1399 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsVorbisSupported = TRUE;
1400 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsLbrSupported = TRUE;
1401 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrNbSupported = TRUE;
1402 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrWbSupported = TRUE;
1403 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDraSupported = TRUE;
1404
1405 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructVersion = AUDIO_OUTPUT_DEVICE_SELECTION_VERSION;
1406 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructSize = sizeof(AUDIO_OUTPUT_DEVICE_SELECTION_t);
1407
1408 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructVersion = AUDIO_SPECIFIED_DIGITAL_OUTPUT_VERSION;
1409 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructSize = sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t);
1410
1411 pAUDIOShared->g_SPDIF_MuteStatus = 0;
1412
1413 pAUDIOShared->AudioSrcType = AUDIO_DSP1_DVB_INPUT;
1414 pAUDIOShared->AudioSubSrcType = AUDIO_DSP1_DVB_INPUT;
1415
1416 pAUDIOShared->g_dolbyLoudness_DTVsystem = DVB_MODE;
1417 pAUDIOShared->g_dolbyLoudness_Enable = 1;
1418 pAUDIOShared->g_hbr_bypass_enable = TRUE;
1419
1420 pAUDIOShared->g_R2_NonPcm_Sel = AU_DEC_ID1;
1421
1422 return TRUE;
1423 }
1424
HAL_AUDIO_AllocateVars(void)1425 AUDIO_SHARED_VARS2 * HAL_AUDIO_AllocateVars(void)
1426 {
1427 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1428
1429 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1430 MS_U32 u32ShmId = 0;
1431 AUDIO_SHARED_VARS2 *virtAddr = 0;
1432 MS_U32 u32BufSize = 0;
1433
1434 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Start %s InitShmFlag=%d\r\n", __FUNCTION__, g_bInitShmFlag);
1435
1436 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
1437 {
1438 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1439
1440 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s QUERY ClientCounter=%u\r\n", __FUNCTION__, pAUDIOShared->g_u32ClientCounter);
1441
1442 if (pAUDIOShared->g_u32ClientCounter == 0)
1443 {
1444 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Resume from Suspend mode, reset Audio SHM data ...\n");
1445 }
1446 }
1447 else
1448 {
1449 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "create Audio SHM data ...\n");
1450
1451 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
1452 {
1453 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Audio SHM data is created\n");
1454 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1455
1456 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "reset Audio SHM data ...\n");
1457 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1458 }
1459 else
1460 {
1461 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "AUDIO SHM allocation failed!\n");
1462 return NULL;
1463 }
1464 }
1465
1466 if (g_bInitShmFlag == FALSE)
1467 {
1468 g_bInitShmFlag = TRUE;
1469 pAUDIOShared->g_u32ClientCounter++;
1470 }
1471
1472 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "End %s InitShmFlag=%d, ClientCounter=%u \r\n", __FUNCTION__, g_bInitShmFlag, pAUDIOShared->g_u32ClientCounter);
1473
1474 #else
1475 pAUDIOShared = &g_audioShared;
1476
1477 if (g_bInitShmFlag == FALSE)
1478 {
1479 HALAUDIO_PRINT("create Audio SHM data ...\n");
1480 g_bInitShmFlag = TRUE;
1481
1482 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1483
1484 pAUDIOShared->g_u32ClientCounter++;
1485 }
1486 #endif
1487 gOpenDecodeSystemFuncPtr = HAL_AUDIO_OpenDecodeSystem;
1488 gDigitalOutChannelStatusFuncPtr = HAL_AUDIO_DigitalOut_SetChannelStatus;
1489 pFuncPtr_Setsystem = HAL_AUDIO_SetDecodeSystem;
1490 gGetDDRInfoFuncPtr = HAL_AUDIO_GetDDRInfo;
1491
1492 return pAUDIOShared;
1493 }
1494
HAL_AUDIO_DeAllocateVars(void)1495 MS_BOOL HAL_AUDIO_DeAllocateVars(void)
1496 {
1497 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1498
1499 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1500 MS_U32 u32ShmId = 0;
1501 AUDIO_SHARED_VARS2 *virtAddr = 0;
1502 MS_U32 u32BufSize = 0;
1503
1504 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Start HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1505
1506 if (g_bInitShmFlag == TRUE)
1507 {
1508 g_bInitShmFlag = FALSE;
1509
1510 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
1511 {
1512 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : No AUDIO SHM is created!\n", __FUNCTION__);
1513 return FALSE;
1514 }
1515
1516 pAUDIOShared = (AUDIO_SHARED_VARS2 *)virtAddr;
1517 pAUDIOShared->g_u32ClientCounter--;
1518
1519 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "HAL_AUDIO_DeAllocateVars ClientCounter=%u\r\n", pAUDIOShared->g_u32ClientCounter);
1520
1521 if (pAUDIOShared->g_u32ClientCounter == 0)
1522 {
1523 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1524
1525 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "free Audio SHM data ...\n");
1526 #if defined(MSOS_TYPE_LINUX)
1527 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_SHM_NAME, u32ShmId) == TRUE)
1528 {
1529 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Audio SHM data is freed\n");
1530 }
1531 else
1532 {
1533 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1534 return FALSE;
1535 }
1536 #endif
1537
1538 HAL_AUDIO_Mutex_DeInit();
1539 }
1540 /* patch for DC off/on no sound issue start */
1541 else
1542 {
1543 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1544 }
1545 /* patch for DC off/on no sound issue end */
1546 }
1547
1548 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "End HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1549 #else
1550 pAUDIOShared = &g_audioShared;
1551
1552 if (g_bInitShmFlag == TRUE)
1553 {
1554 HALAUDIO_PRINT("free Audio SHM data ...\n");
1555 g_bInitShmFlag = FALSE;
1556
1557 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1558 }
1559 #endif
1560
1561 return TRUE;
1562 }
1563
1564 ////////////////////////////////////////////////////////////////////////////////
1565 /// @brief \b Function \b Name: HAL_AUDIO_InitialVars()
1566 /// @brief \b Function \b Description: This routine set audio share memory of Aduio module.
1567 /// @param <IN> \b NONE :
1568 /// @param <OUT> \b NONE :
1569 /// @param <RET> \b NONE :
1570 /// @param <GLOBAL> \b NONE :
1571 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_InitialVars(void)1572 MS_BOOL HAL_AUDIO_InitialVars(void)
1573 {
1574 if (HAL_AUDIO_GET_INIT_FLAG() == FALSE)
1575 {
1576 g_AudioVars2 = HAL_AUDIO_AllocateVars();
1577 if (g_AudioVars2 == NULL)
1578 {
1579 return FALSE;
1580 }
1581
1582 #ifndef MSOS_TYPE_NUTTX
1583 pAudioTeeInfoShm = HAL_AUDIO_AllocateTeeInfoShm();
1584 if (pAudioTeeInfoShm == NULL)
1585 {
1586 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Create Audio TEE INFO SHM data fail...\n");
1587 return FALSE;
1588 }
1589 }
1590 #else
1591 {
1592 MS_U8 audio_mbx_class=0;
1593
1594 MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "MAD", (MS_U8 *)&audio_mbx_class);
1595 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(audio_mbx_class, 10, HAL_AUDIO_HandleDynamicMBX))
1596 {
1597 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD Register MBX MSG error\n");
1598 return FALSE;
1599 }
1600 else
1601 DBG_AUDIO("MAD MBX register msg ok %d\n", audio_mbx_class);
1602
1603 _s32MadEventId = MsOS_CreateEventGroup("MAD_Event");
1604 if (_s32MadEventId < 0)
1605 {
1606 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD CreateEventGroup error....\n");
1607 return FALSE;
1608 }
1609
1610 _s32MadTaskId = MsOS_CreateTask((TaskEntry)_MAD_Proc,
1611 NULL,
1612 E_TASK_PRI_MEDIUM,
1613 TRUE,
1614 NULL,
1615 32, // stack size..
1616 "MAD_ISR_Task");
1617 if (_s32MadTaskId < 0)
1618 {
1619 MsOS_DeleteEventGroup(_s32MadEventId);
1620 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD CreateTask error....\n");
1621 return FALSE;
1622 }
1623 }
1624 }
1625 #endif
1626
1627 return TRUE;
1628 }
1629
1630 ////////////////////////////////////////////////////////////////////////////////
1631 /// @brief \b Function \b Name: HAL_AUDIO_DeInitialVars()
1632 /// @brief \b Function \b Description: This routine delete audio share memory of Aduio module.
1633 /// @param <IN> \b NONE :
1634 /// @param <OUT> \b NONE :
1635 /// @param <RET> \b NONE :
1636 /// @param <GLOBAL> \b NONE :
1637 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DeInitialVars(void)1638 MS_BOOL HAL_AUDIO_DeInitialVars(void)
1639 {
1640 MS_BOOL ret = TRUE;
1641
1642 if (HAL_AUDIO_GET_INIT_FLAG() == TRUE)
1643 {
1644 HAL_AUDIO_SET_INIT_FLAG(FALSE);
1645
1646 ret = HAL_AUDIO_DeAllocateVars();
1647 if (ret == FALSE)
1648 {
1649 HALAUDIO_ERROR ("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1650 }
1651
1652 #if 0 /* patch for STR resume segmentation fault issue */
1653 g_AudioVars2 = NULL;
1654 #endif
1655
1656 #ifndef MSOS_TYPE_NUTTX
1657 {
1658 MS_BOOL ret1;
1659
1660 ret1 = HAL_AUDIO_DeAllocateTeeInfoShm();
1661 if (ret1 == FALSE)
1662 {
1663 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
1664 ret = FALSE;
1665 }
1666 }
1667 #endif
1668 }
1669
1670 return ret;
1671 }
1672
1673 ////////////////////////////////////////////////////////////////////////////////
1674 /// @brief \b Function \b Name: HAL_AUDIO_SET_INIT_FLAG()
1675 /// @brief \b Function \b Description: This routine set the initial status of Aduio module.
1676 /// @param <IN> \b NONE :
1677 /// @param <OUT> \b NONE :
1678 /// @param <RET> \b MS_BOOL :
1679 /// @param <GLOBAL> \b NONE :
1680 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)1681 void HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)
1682 {
1683 HALAUDIO_CHECK_SHM_INIT;
1684
1685 g_AudioVars2->g_Audio_InitFlag = bSet;
1686
1687 return;
1688 }
1689
1690 ////////////////////////////////////////////////////////////////////////////////
1691 /// @brief \b Function \b Name: HAL_AUDIO_GET_INIT_FLAG()
1692 /// @brief \b Function \b Description: This routine get the initial status of Aduio module.
1693 /// @param <IN> \b NONE :
1694 /// @param <OUT> \b NONE :
1695 /// @param <RET> \b MS_BOOL :
1696 /// @param <GLOBAL> \b NONE :
1697 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GET_INIT_FLAG(void)1698 MS_BOOL HAL_AUDIO_GET_INIT_FLAG(void)
1699 {
1700 if (g_AudioVars2 == NULL)
1701 {
1702 return FALSE;
1703 }
1704
1705 return g_AudioVars2->g_Audio_InitFlag;
1706 }
1707
1708 ////////////////////////////////////////////////////////////////////////////////
1709 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_Init()
1710 /// @brief \b Function \b Description: This routine is the initialization of Mutex for Audio module.
1711 /// @param <IN> \b NONE :
1712 /// @param <OUT> \b NONE :
1713 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
1714 /// @param <GLOBAL> \b NONE :
1715 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_Init(void)1716 MS_BOOL HAL_AUDIO_Mutex_Init(void)
1717 {
1718 MS_BOOL ret = TRUE;
1719
1720 if ((_s32AUDIOMutex != -1) &&
1721 (_s32AUDIOMutexReboot != -1) &&
1722 (_s32MutexLoadCode != -1) &&
1723 (_s32AUDIOMutexIDMA != -1))
1724 {
1725 return ret;
1726 }
1727
1728 if (_s32AUDIOMutex == -1)
1729 {
1730 _s32AUDIOMutex = OS_CREATE_MUTEX(AUDIO);
1731 if (_s32AUDIOMutex == -1)
1732 {
1733 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex failed!\n");
1734 ret = FALSE;
1735 }
1736 }
1737
1738 if (_s32AUDIOMutexReboot == -1)
1739 {
1740 _s32AUDIOMutexReboot = OS_CREATE_MUTEX(AUDIOreboot);
1741 if (_s32AUDIOMutexReboot == -1)
1742 {
1743 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for Reboot failed!\n");
1744 ret = FALSE;
1745 }
1746 }
1747
1748 if (_s32MutexLoadCode == -1)
1749 {
1750 _s32MutexLoadCode = OS_CREATE_MUTEX(LOAD_DECDSP);
1751 if (_s32MutexLoadCode == -1)
1752 {
1753 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for Load DSP failed!\n");
1754 ret = FALSE;
1755 }
1756 }
1757
1758 if (_s32AUDIOMutexIDMA == -1)
1759 {
1760 _s32AUDIOMutexIDMA = OS_CREATE_MUTEX(AUDIO_IDMA);
1761 if (_s32AUDIOMutexIDMA == -1)
1762 {
1763 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for IMDA failed!\n");
1764 ret = FALSE;
1765 }
1766 }
1767
1768 if (ret == FALSE)
1769 {
1770 if (_s32AUDIOMutex != -1)
1771 {
1772 OS_DELETE_MUTEX(_s32AUDIOMutex);
1773 _s32AUDIOMutex = -1;
1774 }
1775
1776 if (_s32AUDIOMutexReboot != -1)
1777 {
1778 OS_DELETE_MUTEX(_s32AUDIOMutexReboot);
1779 _s32AUDIOMutexReboot = -1;
1780 }
1781
1782 if (_s32MutexLoadCode != -1)
1783 {
1784 OS_DELETE_MUTEX(_s32MutexLoadCode);
1785 _s32MutexLoadCode = -1;
1786 }
1787
1788 if (_s32AUDIOMutexIDMA != -1)
1789 {
1790 OS_DELETE_MUTEX(_s32AUDIOMutexIDMA);
1791 _s32AUDIOMutexIDMA = -1;
1792 }
1793 }
1794
1795 return ret;
1796 }
1797
1798 ////////////////////////////////////////////////////////////////////////////////
1799 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_DeInit()
1800 /// @brief \b Function \b Description: This routine is the deletion of Mutex for Audio module.
1801 /// @param <IN> \b NONE :
1802 /// @param <OUT> \b NONE :
1803 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
1804 /// @param <GLOBAL> \b NONE :
1805 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_DeInit(void)1806 MS_BOOL HAL_AUDIO_Mutex_DeInit(void)
1807 {
1808 MS_BOOL ret = TRUE;
1809
1810 if ((_s32AUDIOMutex == -1) &&
1811 (_s32AUDIOMutexReboot == -1) &&
1812 (_s32MutexLoadCode == -1) &&
1813 (_s32AUDIOMutexIDMA == -1))
1814 {
1815 return ret;
1816 }
1817
1818 if (_s32AUDIOMutex != -1)
1819 {
1820 if (OS_DELETE_MUTEX(_s32AUDIOMutex) != TRUE)
1821 {
1822 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex failed!\n");
1823 ret = FALSE;
1824 }
1825 _s32AUDIOMutex = -1;
1826 }
1827
1828 if (_s32AUDIOMutexReboot != -1)
1829 {
1830 if (OS_DELETE_MUTEX(_s32AUDIOMutexReboot) != TRUE)
1831 {
1832 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for Reboot failed!\n");
1833 ret = FALSE;
1834 }
1835 _s32AUDIOMutexReboot = -1;
1836 }
1837
1838 if (_s32MutexLoadCode != -1)
1839 {
1840 if (OS_DELETE_MUTEX(_s32MutexLoadCode) != TRUE)
1841 {
1842 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for Load DSP failed!\n");
1843 ret = FALSE;
1844 }
1845 _s32MutexLoadCode = -1;
1846 }
1847
1848 if (_s32AUDIOMutexIDMA != -1)
1849 {
1850 if (OS_DELETE_MUTEX(_s32AUDIOMutexIDMA) != TRUE)
1851 {
1852 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for IMDA failed!\n");
1853 ret = FALSE;
1854 }
1855 _s32AUDIOMutexIDMA = -1;
1856 }
1857
1858 return ret;
1859 }
1860
1861 ////////////////////////////////////////////////////////////////////////////////
1862 /// @brief \b Function \b Name: HAL_AUDIO_GetChipType() @@Cathy
1863 /// @brief \b Function \b Description: This routine is used to get the IC version for API.
1864 /// @param <IN> \b NONE :
1865 /// @param <OUT> \b NONE :
1866 /// @param <RET> \b AU_CHIP_TYPE :
1867 /// @param <GLOBAL> \b NONE :
1868 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetChipType(void)1869 AU_CHIP_TYPE HAL_AUDIO_GetChipType(void)
1870 {
1871 return AU_CHIP_KERES; //Need to refine
1872 }
1873
1874 ////////////////////////////////////////////////////////////////////////////////
1875 /// @brief \b Function \b Name: HAL_AUDIO_Set_MMIO_BASE() @@Cathy
1876 /// @brief \b Function \b Description: This routine is used to set MMIO base
1877 /// @param <IN> \b u32_MMIO_MapBase :
1878 /// @param <OUT> \b NONE :
1879 /// @param <RET> \b :
1880 /// @param <GLOBAL> \b NONE :
1881 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)1882 void HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)
1883 {
1884 _gMIO_MapBase = _MMIO_MapBase; // Get the absolute MMIO address
1885 }
1886
1887 //-------------------------------------------------------------------------------------------------
1888 // Global Functions
1889 //-------------------------------------------------------------------------------------------------
1890
1891 ////////////////////////////////////////////////////////////////////////////////
1892 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadByte @@Cathy
1893 /// @brief \b Function \b Description: read 1 Byte data
1894 /// @param <IN> \b u32RegAddr: register address
1895 /// @param <OUT> \b None :
1896 /// @param <RET> \b MS_U8 : 8-bit register value
1897 /// @param <GLOBAL> \b None :
1898 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)1899 MS_U8 HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)
1900 {
1901 return (_AU_AbsReadByte((u32RegAddr-0x100000)));
1902 }
1903
1904 ////////////////////////////////////////////////////////////////////////////////
1905 /// @brief \b Function \b Name: HAL_AUDIO_ReadByte @@Cathy
1906 /// @brief \b Function \b Description: read 1 Byte data
1907 /// @param <IN> \b u32RegAddr: register address
1908 /// @param <OUT> \b None :
1909 /// @param <RET> \b MS_U8 : 8-bit register value
1910 /// @param <GLOBAL> \b None :
1911 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)1912 MS_U8 HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)
1913 {
1914 return (_AU_AbsReadByte(u32RegAddr+0x010000)); // Add audio bank offset
1915 }
1916
1917
1918 ////////////////////////////////////////////////////////////////////////////////
1919 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadReg @@Cathy
1920 /// @brief \b Function \b Description: read 2 Byte data
1921 /// @param <IN> \b u32RegAddr: register address
1922 /// @param <OUT> \b None :
1923 /// @param <RET> \b MS_U16 : 16-bit register value
1924 /// @param <GLOBAL> \b None :
1925 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)1926 MS_U16 HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)
1927 {
1928 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1929 return _AU_AbsRead2Byte((u32RegAddr-0x100000)); // Add audio bank offset
1930 }
1931
1932 ////////////////////////////////////////////////////////////////////////////////
1933 /// @brief \b Function \b Name: HAL_AUDIO_ReadReg @@Cathy
1934 /// @brief \b Function \b Description: read 2 Byte data
1935 /// @param <IN> \b u32RegAddr: register address
1936 /// @param <OUT> \b None :
1937 /// @param <RET> \b MS_U16 : 16-bit register value
1938 /// @param <GLOBAL> \b None :
1939 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)1940 MS_U16 HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)
1941 {
1942 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1943 return (_AU_AbsRead2Byte(u32RegAddr+0x010000)); // Add audio bank offset
1944 }
1945
1946 ////////////////////////////////////////////////////////////////////////////////
1947 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteReg
1948 /// @brief \b Function \b Description: write 2 Byte data
1949 /// @param <IN> \b u32RegAddr: register address
1950 /// @param <IN> \b u16Val : 2 byte data
1951 /// @param <OUT> \b None :
1952 /// @param <RET> \b None :
1953 /// @param <GLOBAL> \b None :
1954 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)1955 void HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
1956 {
1957 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1958 _AU_AbsWrite2Byte((u32RegAddr-0x100000),u16Val); // Add audio bank offset
1959 }
1960
1961 ////////////////////////////////////////////////////////////////////////////////
1962 /// @brief \b Function \b Name: HAL_AUDIO_WriteReg @@Cathy
1963 /// @brief \b Function \b Description: write 2 Byte data
1964 /// @param <IN> \b u32RegAddr: register address
1965 /// @param <IN> \b u16Val : 2 byte data
1966 /// @param <OUT> \b None :
1967 /// @param <RET> \b None :
1968 /// @param <GLOBAL> \b None :
1969 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)1970 void HAL_AUDIO_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
1971 {
1972 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1973 _AU_AbsWrite2Byte((u32RegAddr+0x010000),u16Val); // Add audio bank offset
1974 }
1975
1976 ////////////////////////////////////////////////////////////////////////////////
1977 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteByte
1978 /// @brief \b Function \b Description: write 1 Byte data
1979 /// @param <IN> \b u32RegAddr: register address
1980 /// @param <IN> \b u8Val : 1 byte data
1981 /// @param <OUT> \b None :
1982 /// @param <RET> \b None :
1983 /// @param <GLOBAL> \b None :
1984 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)1985 void HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
1986 {
1987 _AU_AbsWriteByte((u32RegAddr-0x100000), u8Val); // Add audio bank offset
1988 }
1989
1990 ////////////////////////////////////////////////////////////////////////////////
1991 /// @brief \b Function \b Name: HAL_AUDIO_WriteByte @@Cathy
1992 /// @brief \b Function \b Description: write 1 Byte data
1993 /// @param <IN> \b u32RegAddr: register address
1994 /// @param <IN> \b u8Val : 1 byte data
1995 /// @param <OUT> \b None :
1996 /// @param <RET> \b None :
1997 /// @param <GLOBAL> \b None :
1998 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)1999 void HAL_AUDIO_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2000 {
2001 _AU_AbsWriteByte((u32RegAddr+0x010000), u8Val); // Add audio bank offset
2002 }
2003
2004 ////////////////////////////////////////////////////////////////////////////////
2005 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskByte @@Morris
2006 /// @brief \b Function \b Description: Mask write 8-bit data
2007 /// @param <IN> \b u32RegAddr: register address
2008 /// @param <IN> \b u16Val : 8-bit data
2009 /// @param <OUT> \b None :
2010 /// @param <RET> \b None :
2011 /// @param <GLOBAL> \b None :
2012 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2013 void HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2014 {
2015 _AU_AbsWriteMaskByte((u32RegAddr-0x100000), u8Mask, u8Val);
2016 }
2017
2018 ////////////////////////////////////////////////////////////////////////////////
2019 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskByte @@Cathy
2020 /// @brief \b Function \b Description: Mask write 8-bit data
2021 /// @param <IN> \b u32RegAddr: register address
2022 /// @param <IN> \b u16Val : 8-bit data
2023 /// @param <OUT> \b None :
2024 /// @param <RET> \b None :
2025 /// @param <GLOBAL> \b None :
2026 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2027 void HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2028 {
2029 _AU_AbsWriteMaskByte((u32RegAddr+0x010000), u8Mask, u8Val); // Add audio bank offset
2030 }
2031
2032 ////////////////////////////////////////////////////////////////////////////////
2033 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskReg
2034 /// @brief \b Function \b Description: Mask write 16-bit data
2035 /// @param <IN> \b u32RegAddr: register address
2036 /// @param <IN> \b u16Val : 16-bit data
2037 /// @param <OUT> \b None :
2038 /// @param <RET> \b None :
2039 /// @param <GLOBAL> \b None :
2040 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2041 void HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2042 {
2043 MS_U16 u16RegVal;
2044
2045 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2046 u16RegVal = _AU_AbsRead2Byte((u32RegAddr-0x100000));
2047 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2048 _AU_AbsWrite2Byte((u32RegAddr-0x100000), u16RegVal);
2049 }
2050
2051 ////////////////////////////////////////////////////////////////////////////////
2052 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskReg @@Cathy
2053 /// @brief \b Function \b Description: Mask write 16-bit data
2054 /// @param <IN> \b u32RegAddr: register address
2055 /// @param <IN> \b u16Val : 16-bit data
2056 /// @param <OUT> \b None :
2057 /// @param <RET> \b None :
2058 /// @param <GLOBAL> \b None :
2059 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2060 void HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2061 {
2062 MS_U16 u16RegVal;
2063
2064 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2065 u16RegVal = HAL_AUDIO_ReadReg(u32RegAddr);
2066 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2067 HAL_AUDIO_WriteReg(u32RegAddr, u16RegVal);
2068 }
2069
2070 ////////////////////////////////////////////////////////////////////////////////
2071 /// @brief \b Function \b Name: _HAL_AUDIO_Write4Byte @@Cathy
2072 /// @brief \b Function \b Description: write 4 Byte data
2073 /// @param <IN> \b u32RegAddr: register address
2074 /// @param <IN> \b u32Val : 4 byte data
2075 /// @param <OUT> \b None :
2076 /// @param <RET> \b None :
2077 /// @param <GLOBAL> \b None :
2078 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)2079 void _HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
2080 {
2081 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+0x010000] =(MS_U16) (u32Val&0xFFFF);
2082 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+2+0x010000] =(MS_U16) (u32Val>>16);
2083 }
2084
2085 ////////////////////////////////////////////////////////////////////////////////
2086 /// @brief \b Function \b Name: HAL_AUDIO_ReadMailBox() @@Need_Modify
2087 /// @brief \b Function \b Description: This routine is used to read the Dec or SE DSP mail box value
2088 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2089 /// @param <IN> \b u8ParamNum : Mail box address
2090 /// @param <OUT> \b NONE :
2091 /// @param <RET> \b U16 : Mail Box value
2092 /// @param <GLOBAL> \b NONE :
2093 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum)2094 MS_U16 HAL_AUDIO_ReadMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum)
2095 {
2096 MS_U16 u16Tmp1, u16Tmp2;
2097 MS_U32 i, u32MailReg;
2098
2099
2100 for (i=0; i<1000; i++)
2101 {
2102 if(bDspType==DSP_SE)
2103 {
2104 if(u8ParamNum<8)
2105 {
2106 u32MailReg = 0x2D70+(MS_U32)u8ParamNum * 2;
2107 }
2108 else
2109 {
2110 u32MailReg = REG_SE_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2111 }
2112 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2113 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2114 }
2115 else
2116 {
2117 if(u8ParamNum<8)
2118 {
2119 u32MailReg = 0x2D60+(MS_U32)u8ParamNum * 2;
2120 }
2121 else
2122 {
2123 u32MailReg = REG_DEC_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2124 }
2125 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2126 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2127 }
2128 if(u16Tmp1==u16Tmp2)
2129 {
2130 return u16Tmp1;
2131 }
2132 }
2133
2134 printf("Read Mailbox fail! \r\n");
2135 return 0;
2136
2137 }
2138
2139 ////////////////////////////////////////////////////////////////////////////////
2140 /// @brief \b Function \b Name: HAL_AUDIO_WriteDecMailBox() @@Need_Modify
2141 /// @brief \b Function \b Description: This routine is used to write Dec-DSP mail box
2142 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2143 /// @param <IN> \b u8ParamNum : Mail box address
2144 /// @param <IN> \b u16Data : value
2145 /// @param <OUT> \b NONE :
2146 /// @param <RET> \b NONE :
2147 /// @param <GLOBAL> \b NONE :
2148 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum,MS_U16 u16Data)2149 void HAL_AUDIO_WriteMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum, MS_U16 u16Data)
2150 {
2151 MS_U32 u32MailReg;
2152
2153 if(bDspType==DSP_SE)
2154 {
2155 u32MailReg = REG_SE_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2156 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2157 }
2158 else
2159 {
2160 u32MailReg = REG_DEC_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2161 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2162 }
2163 }
2164
2165
2166 ///-----------------------------------------------------------------------------
2167 ////////////////////////////////////////////////////////////////////////////////
2168 ////////////////////////////////////////////////////////////////////////////////
2169 ///
2170 /// AUDIO Initialize Relational Hal Function
2171 ///
2172 ////////////////////////////////////////////////////////////////////////////////
2173
2174 ////////////////////////////////////////////////////////////////////////////////
2175 ///-----------------------------------------------------------------------------
2176 ////////////////////////////////////////////////////////////////////////////////
2177 /// @brief \b Function \b Name: HAL_AUDIO_WriteInitTable() @@Cathy
2178 /// @brief \b Function \b Description: This function is used to write initial register table(8-bit mode)
2179 /// @param <IN> \b NONE :
2180 /// @param <OUT> \b NONE :
2181 /// @param <RET> \b NONE :
2182 /// @param <GLOBAL> \b NONE :
2183 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteInitTable(void)2184 void HAL_AUDIO_WriteInitTable(void)
2185 {
2186 MS_U16 i = 0;
2187 MS_U16 j = 0;
2188
2189 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2190 {
2191 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2192 {
2193 if(ResetDMIOTbl[j].u16Mask == 1)
2194 {
2195 if(ResetDMIOTbl[j].u16Value!=0)
2196 MsOS_DelayTask((MS_U32)(ResetDMIOTbl[j].u16Value));
2197 }
2198 }
2199 else
2200 {
2201 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2202 }
2203
2204 j++;
2205 }
2206
2207 while( !((AudioInitTbl[i].u32Addr == 0xFFFFFF) && (AudioInitTbl[i].u8Mask == 0)) )
2208 {
2209 if((AudioInitTbl[i].u32Addr == 0xFFFFFF))
2210 {
2211 if(AudioInitTbl[i].u8Mask == 1)
2212 {
2213 if(AudioInitTbl[i].u8Value!=0)
2214 MsOS_DelayTask((MS_U32)(AudioInitTbl[i].u8Value));
2215 }
2216 }
2217 else
2218 {
2219 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl[i].u32Addr, AudioInitTbl[i].u8Mask, AudioInitTbl[i].u8Value);
2220 }
2221 i++;
2222 }
2223
2224 }
2225
2226 ////////////////////////////////////////////////////////////////////////////////
2227 /// @brief \b Function \b Name: HAL_AUDIO_WritePreInitTable()
2228 /// @brief \b Function \b Description: This function is used to set power on DAC sequence before setting init table.
2229 /// @param <IN> \b NONE :
2230 /// @param <OUT> \b NONE :
2231 /// @param <RET> \b NONE :
2232 /// @param <GLOBAL> \b NONE :
2233 ////////////////////////////////////////////////////////////////////////////////
2234 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_WritePreInitTable(void)2235 void HAL_AUDIO_WritePreInitTable(void)
2236 {
2237 MS_U16 i = 0;
2238
2239 while( !((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock[i].u8Mask == 0)) )
2240 {
2241 if((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF))
2242 {
2243 if(AudioPreInitTbl_Clock[i].u8Mask == 1)
2244 {
2245 if(AudioPreInitTbl_Clock[i].u8Value!=0)
2246 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock[i].u8Value));
2247 }
2248 }
2249 else
2250 {
2251 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock[i].u32Addr, AudioPreInitTbl_Clock[i].u8Mask, AudioPreInitTbl_Clock[i].u8Value);
2252 }
2253 i++;
2254 }
2255 }
2256
2257 ////////////////////////////////////////////////////////////////////////////////
2258 /// @brief \b Function \b Name: HAL_AUDIO_WriteStopDecTable()
2259 /// @brief \b Function \b Description: This function is used to set stop command to R2/DSP.
2260 /// @param <IN> \b NONE :
2261 /// @param <OUT> \b NONE :
2262 /// @param <RET> \b NONE :
2263 /// @param <GLOBAL> \b NONE :
2264 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteStopDecTable(void)2265 void HAL_AUDIO_WriteStopDecTable(void)
2266 {
2267 MS_U16 i = 0;
2268
2269 while( !((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF) && (Audio_stopDecTbl[i].u8Mask == 0)) )
2270 {
2271 if((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF))
2272 {
2273 if(Audio_stopDecTbl[i].u8Mask == 1)
2274 {
2275 if(Audio_stopDecTbl[i].u8Value!=0)
2276 MsOS_DelayTask((MS_U32)(Audio_stopDecTbl[i].u8Value));
2277 }
2278 }
2279 else
2280 {
2281 HAL_AUDIO_AbsWriteMaskByte(Audio_stopDecTbl[i].u32Addr, Audio_stopDecTbl[i].u8Mask, Audio_stopDecTbl[i].u8Value);
2282 }
2283 i++;
2284 }
2285 }
2286
2287 ////////////////////////////////////////////////////////////////////////////////
2288 /// @brief \b Function \b Name: HAL_AUDIO_DAC_Clock_OnOff()
2289 /// @brief \b Function \b Description: This function is used to set DAC power on and off sequence.
2290 /// @param <IN> \b NONE :
2291 /// @param <OUT> \b NONE :
2292 /// @param <RET> \b NONE :
2293 /// @param <GLOBAL> \b NONE :
2294 ////////////////////////////////////////////////////////////////////////////////
2295 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_DAC_Clock_OnOff(MS_BOOL b_enable)2296 void HAL_AUDIO_DAC_Clock_OnOff(MS_BOOL b_enable)
2297 {
2298 MS_U16 i = 0;
2299
2300 if (b_enable)
2301 {
2302 while( !((AudioAUSDMTbl_On[i].u32Addr == 0xFFFFFF) && (AudioAUSDMTbl_On[i].u8Mask == 0)) )
2303 {
2304 if((AudioAUSDMTbl_On[i].u32Addr == 0xFFFFFF))
2305 {
2306 if(AudioAUSDMTbl_On[i].u8Mask == 1)
2307 {
2308 if(AudioAUSDMTbl_On[i].u8Value!=0)
2309 MsOS_DelayTask((MS_U32)(AudioAUSDMTbl_On[i].u8Value));
2310 }
2311 }
2312 else
2313 {
2314 HAL_AUDIO_AbsWriteMaskByte(AudioAUSDMTbl_On[i].u32Addr, AudioAUSDMTbl_On[i].u8Mask, AudioAUSDMTbl_On[i].u8Value);
2315 }
2316
2317 i++;
2318
2319 }
2320 }
2321 else
2322 {
2323 while( !((AudioAUSDMTbl_Off[i].u32Addr == 0xFFFFFF) && (AudioAUSDMTbl_Off[i].u8Mask == 0)) )
2324 {
2325 if((AudioAUSDMTbl_Off[i].u32Addr == 0xFFFFFF))
2326 {
2327 if(AudioAUSDMTbl_Off[i].u8Mask == 1)
2328 {
2329 if(AudioAUSDMTbl_Off[i].u8Value!=0)
2330 MsOS_DelayTask((MS_U32)(AudioAUSDMTbl_Off[i].u8Value));
2331 }
2332 }
2333 else
2334 {
2335 HAL_AUDIO_AbsWriteMaskByte(AudioAUSDMTbl_Off[i].u32Addr, AudioAUSDMTbl_Off[i].u8Mask, AudioAUSDMTbl_Off[i].u8Value);
2336 }
2337
2338 i++;
2339
2340 }
2341 }
2342 }
2343
2344 ////////////////////////////////////////////////////////////////////////////////
2345 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2346 /// @brief \b Function \b Description: This function is used to enable earphone low power stage.
2347 /// @param <IN> \b NONE :
2348 /// @param <OUT> \b NONE :
2349 /// @param <RET> \b NONE :
2350 /// @param <GLOBAL> \b NONE :
2351 ////////////////////////////////////////////////////////////////////////////////
2352 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_LowPower_Stage(void)2353 void HAL_AUDIO_EnaEarphone_LowPower_Stage(void)
2354 {
2355 HAL_AUDIO_AbsWriteMaskByte(0x112B55,0x10,0x00); // disable DWA fix value
2356 return;
2357 }
2358
2359 ////////////////////////////////////////////////////////////////////////////////
2360 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2361 /// @brief \b Function \b Description: This function is used to enable earphone high driving stage.
2362 /// @param <IN> \b NONE :
2363 /// @param <OUT> \b NONE :
2364 /// @param <RET> \b NONE :
2365 /// @param <GLOBAL> \b NONE :
2366 ////////////////////////////////////////////////////////////////////////////////
2367 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)2368 void HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)
2369 {
2370 return;
2371 }
2372
2373 ////////////////////////////////////////////////////////////////////////////////
2374 /// @brief \b Function \b Name: HAL_AUDIO_SetPowerOn() @@Need_Modify
2375 /// @brief \b Function \b Description: This routine is used to execute DSP power on/down setting.
2376 /// @param <IN> \b bPower_on : TRUE --power on
2377 /// FALSE--power off
2378 /// @param <OUT> \b NONE :
2379 /// @param <RET> \b NONE :
2380 /// @param <GLOBAL> \b NONE :
2381 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)2382 void HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)
2383 {
2384 DBG_AUDIO("HAL_AUDIO_SetPowerOn(%x)\r\n", bPower_on);
2385 if(bPower_on)
2386 {
2387 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x00); // DSP power up command, DO NOT touch bit3
2388 HAL_AUDIO_WriteMaskByte(0x2B42, 0xFF, 0x00); // Disable BB by-pass
2389 }
2390 else
2391 {
2392 HAL_AUDIO_DeInitialVars();
2393
2394 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x02); // DSP power down command
2395 AUDIO_DELAY1MS(100);
2396
2397 // Disable MIU Request for DEC-DSP
2398 HAL_MAD_Dis_MIUREQ();
2399 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00); // SPDIF power down
2400 }
2401 }
2402
2403 ////////////////////////////////////////////////////////////////////////////////
2404 /// @brief \b Function \b Name: HAL_AUDIO_ADCInit() @@Cathy
2405 /// @brief \b Function \b Description: This routine is ADC relational register Init.
2406 /// @param <IN> \b NONE :
2407 /// @param <OUT> \b NONE :
2408 /// @param <RET> \b NONE :
2409 /// @param <GLOBAL> \b NONE :
2410 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ADCInit(void)2411 void HAL_AUDIO_ADCInit(void)
2412 {
2413 HAL_AUDIO_WriteMaskByte(0x2CDA, 0x03, 0x00); // power on ADC0 & ADC1
2414 HAL_AUDIO_WriteMaskByte(0x2CEE, 0x03, 0x03); //enable ADC dither
2415 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00); // power on ADC PGA
2416 HAL_AUDIO_WriteMaskByte(0x2CE5, 0xFC, 0x00); //ADC0 & ADC1 PGAain=0dB
2417 }
2418
2419 ////////////////////////////////////////////////////////////////////////////////
2420 /// @brief \b Function \b Name: HAL_AUDIO_SwResetMAD() @@Cathy
2421 /// @brief \b Function \b Description: This function is used to software reset MAD
2422 /// @param <IN> \b NONE :
2423 /// @param <OUT> \b NONE :
2424 /// @param <RET> \b NONE :
2425 /// @param <GLOBAL> \b NONE :
2426 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SwResetMAD(void)2427 void HAL_AUDIO_SwResetMAD(void)
2428 {
2429 MS_U16 j = 0;
2430
2431 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2432 {
2433 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2434 {
2435 if(ResetDMIOTbl[j].u16Mask == 1)
2436 {
2437 if(ResetDMIOTbl[j].u16Value!=0)
2438 AUDIO_DELAY1MS((MS_U32)(ResetDMIOTbl[j].u16Value));
2439 }
2440 }
2441 else
2442 {
2443 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2444 }
2445
2446 j++;
2447 }
2448
2449 /* Audio software engine reset */
2450 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0D);
2451 AUDIO_DELAY1MS(1);
2452 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0F);
2453 AUDIO_DELAY1MS(1);
2454 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0D);
2455 AUDIO_DELAY1MS(1);
2456 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x00);
2457 AUDIO_DELAY1MS(1);
2458 }
2459
2460 ////////////////////////////////////////////////////////////////////////////////
2461 /// @brief \b Function \b Name: HAL_AUDIO_ResetDSP() @@Cathy
2462 /// @brief \b Function \b Description: This function is used to reset DSP.
2463 /// @param <IN> \b NONE :
2464 /// @param <OUT> \b NONE :
2465 /// @param <RET> \b NONE :
2466 /// @param <GLOBAL> \b NONE :
2467 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ResetDSP(void)2468 void HAL_AUDIO_ResetDSP(void)
2469 {
2470 HAL_AUDIO_DecWriteByte(REG_SE_IDMA_CTRL0, 0x82); // Reset DSP
2471 AUDIO_DELAY1MS(2);
2472 HAL_AUDIO_DecWriteByte(REG_SE_IDMA_CTRL0, 0x83);
2473 }
2474
2475 ////////////////////////////////////////////////////////////////////////////////
2476 /// @brief \b Function \b Name: HAL_AUDIO_DecDspISR() @@Need_Modify
2477 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2478 /// @param <IN> \b NONE :
2479 /// @param <OUT> \b NONE :
2480 /// @param <RET> \b NONE :
2481 /// @param <GLOBAL> \b NONE :
2482 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecDspISR(void)2483 void HAL_AUDIO_DecDspISR(void) //Cathy need modify
2484 {
2485 MS_U8 dec_ISR_cmdType;
2486
2487 dec_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_DEC_ISRCMD);
2488
2489 HALAUDIO_CHECK_SHM_INIT;
2490
2491 if(dec_ISR_cmdType == 0x3)
2492 {
2493 g_AudioVars2->g_bDecPlayFileFlag = TRUE;
2494 }
2495 else if(dec_ISR_cmdType == 0x13) // MPEG encode ISR
2496 {
2497 HAL_AUDIO_SetEncodeDoneFlag(1); // for PVR encode done, kochien modified
2498 EncBuf_Count++; // remaining data in buffer
2499 EncFrameIdx += 16; //default 16 frames / interrupt
2500 MPEG_EN_BUF[EncBuf_W_idx].u32Addr = ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINEADDR))*16;
2501 MPEG_EN_BUF[EncBuf_W_idx].u32Size= ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINESIZE))*16;
2502 MPEG_EN_BUF[EncBuf_W_idx].u64Idx= (MS_U64)EncFrameIdx; //(MS_U64)(((EncFrameIdx-1)*1152*90)/48);
2503
2504 if(EncBuf_W_idx == 5)// (ENC_BUF_SIZE-1)) // circular buffer // manually circular...
2505 EncBuf_W_idx = 0;
2506 else
2507 EncBuf_W_idx++;
2508 }
2509 else if (dec_ISR_cmdType == 0x07) // 2nd Decoder ISR in MM
2510 {
2511 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2512 }
2513 }
2514
2515 ////////////////////////////////////////////////////////////////////////////////
2516 /// @brief \b Function \b Name: HAL_AUDIO_SeDspISR() @@Need_Modify
2517 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2518 /// @param <IN> \b NONE :
2519 /// @param <OUT> \b NONE :
2520 /// @param <RET> \b NONE :
2521 /// @param <GLOBAL> \b NONE :
2522 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeDspISR(void)2523 void HAL_AUDIO_SeDspISR(void)
2524 {
2525 MS_U8 se_ISR_cmdType;
2526
2527 se_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_SE_ISRCMD);
2528
2529 /* add for PIP ASND Decode */
2530 if ( se_ISR_cmdType == 0x03 )
2531 {
2532 if (g_AudioVars2 != NULL)
2533 {
2534 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2535 }
2536 }
2537 }
2538
2539 ////////////////////////////////////////////////////////////////////////////////
2540 /// @brief \b Function \b Name: HAL_AUDIO_SetPlayFileFlag() @Cathy
2541 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2542 /// @param <IN> \b NONE :
2543 /// @param <OUT> \b NONE :
2544 /// @param <RET> \b NONE :
2545 /// @param <GLOBAL> \b NONE :
2546 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType,MS_BOOL bSet)2547 void HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType, MS_BOOL bSet)
2548 {
2549 HALAUDIO_CHECK_SHM_INIT;
2550
2551 if(bDspType == DSP_DEC)
2552 {
2553 g_AudioVars2->g_bDecPlayFileFlag = bSet;
2554 }
2555 else
2556 {
2557 g_AudioVars2->g_bSePlayFileFlag = bSet;
2558 }
2559 }
2560
2561 ////////////////////////////////////////////////////////////////////////////////
2562 /// @brief \b Function \b Name: HAL_AUDIO_GetPlayFileFlag() @@Cathy
2563 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2564 /// @param <IN> \b NONE :
2565 /// @param <OUT> \b NONE :
2566 /// @param <RET> \b NONE :
2567 /// @param <GLOBAL> \b NONE :
2568 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)2569 MS_BOOL HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)
2570 {
2571 MS_U32 es_rdPtr, es_wrPtr;
2572 MS_S32 es_level, es_bufSz, es_freeSpace;
2573 MS_U32 es_reqSize;
2574 MS_U8 r2_dec_id;
2575
2576 if(bDspType ==DSP_DEC)
2577 r2_dec_id = AU_DEC_ID1;
2578 else if(bDspType ==DSP_SE)
2579 r2_dec_id = AU_DEC_ID3;
2580 else
2581 r2_dec_id = AU_DEC_ID1; //default case
2582
2583 es_rdPtr = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, r2_dec_id );
2584 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM( R2_SHM_PARAM_ES_WR_PTR, r2_dec_id, 0 );
2585 es_reqSize = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, r2_dec_id);
2586
2587 if (r2_dec_id == AU_DEC_ID1)
2588 es_bufSz = ES1_DRAM_SIZE;
2589 else
2590 es_bufSz = ES3_DRAM_SIZE;
2591
2592 es_level = es_wrPtr - es_rdPtr;
2593
2594 if (es_level < 0)
2595 es_level += es_bufSz;
2596
2597 es_freeSpace = es_bufSz - es_level;
2598
2599 if ( es_freeSpace > es_reqSize )
2600 return TRUE;
2601 else
2602 return FALSE;
2603 }
2604
2605 ////////////////////////////////////////////////////////////////////////////////
2606 /// @brief \b Function \b Name: HAL_AUDIO_SetEncodeDoneFlag() @@Cathy
2607 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2608 /// @param <IN> \b NONE :
2609 /// @param <OUT> \b NONE :
2610 /// @param <RET> \b NONE :
2611 /// @param <GLOBAL> \b NONE :
2612 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)2613 void HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)
2614 {
2615 if(bSet)
2616 g_bEncodeDoneFlag= 1;
2617 else
2618 g_bEncodeDoneFlag = 0;
2619 }
2620
2621 ////////////////////////////////////////////////////////////////////////////////
2622 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeDoneFlag() @@Cathy
2623 /// @brief \b Function \b Description: This function is used to get the Encoder flag status
2624 /// @param <IN> \b NONE :
2625 /// @param <OUT> \b NONE :
2626 /// @param <RET> \b NONE :
2627 /// @param <GLOBAL> \b NONE :
2628 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeDoneFlag(void)2629 MS_BOOL HAL_AUDIO_GetEncodeDoneFlag(void)
2630 {
2631 return g_bEncodeDoneFlag;
2632 }
2633
2634 ////////////////////////////////////////////////////////////////////////////////
2635 /// @brief \b Function \b Name: HAL_AUDIO_CheckBootOnInitState()
2636 /// @brief \b Function \b Description: This routine is used to check whether mboot load init script
2637 /// @param void
2638 /// @return MS_U16 \b : Mail Box value
2639 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckBootOnInitState(void)2640 MS_BOOL HAL_AUDIO_CheckBootOnInitState(void)
2641 {
2642 if ((HAL_AUDIO_ReadByte(REG_AUDIO_AUDIO_INIT_CHECK) & 0x1) == 0)
2643 {
2644 return FALSE;
2645 }
2646 else
2647 {
2648 return TRUE;
2649 }
2650 }
2651
2652 /////////////////////////////////////////////////////////////////////////////////
2653 /// ///
2654 /// AUDIO I/O Config Relational Hal Function ///
2655 /// ///
2656 ////////////////////////////////////////////////////////////////////////////////
2657
2658 ////////////////////////////////////////////////////////////////////////////////
2659 /// @brief \b Function \b Name: HAL_AUDIO_GetPathGroup()
2660 /// @brief \b Function \b Description: This routine is used to get Audio path group type .
2661 /// @param output \b : Audio output path-group type
2662 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPathGroup(void)2663 AUDIO_PATH_GROUP_TYPE HAL_AUDIO_GetPathGroup(void)
2664 {
2665 // AUDIO_PATH_GROUP_1 : U3, Janus
2666 // AUDIO_PATH_GROUP_2 : T3, U4, T8, T9, T12, T13, J2
2667 return(AUDIO_PATH_GROUP_2);
2668 }
2669
2670 ////////////////////////////////////////////////////////////////////////////////
2671 /// @brief \b Function \b Name: HAL_AUDIO_SetNormalPath() @@ No used in T3 @@VVV
2672 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input and Output.
2673 /// @param <IN> \b u8Path : Audio DSP channel
2674 /// @param <IN> \b input : Audio input type
2675 /// @param <IN> \b output : Audio output type
2676 /// @param <OUT> \b NONE :
2677 /// @param <RET> \b NONE :
2678 /// @param <GLOBAL> \b NONE :
2679 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path,AUDIO_INPUT_TYPE input,AUDIO_OUTPUT_TYPE output)2680 void HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path, AUDIO_INPUT_TYPE input, AUDIO_OUTPUT_TYPE output)
2681 {
2682 u8Path=u8Path;
2683 input=input;
2684 output=output;
2685 }
2686
2687 ////////////////////////////////////////////////////////////////////////////////
2688 /// @brief \b Function \b Name: HAL_AUDIO_SetInputPath() @@VVV
2689 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input .
2690 /// @param <IN> \b input : Audio input type
2691 /// @param <IN> \b u8Path : Audio DSP channel
2692 /// @param <OUT> \b NONE :
2693 /// @param <RET> \b NONE :
2694 /// @param <GLOBAL> \b NONE :
2695 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input,AUDIO_PATH_TYPE u8Path)2696 void HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input , AUDIO_PATH_TYPE u8Path)
2697 {
2698 MS_U32 u32path_reg;
2699 MS_U8 u8input_src, u8input_idx, u8temp, path;
2700 AUDIO_INPUT_TYPE input1; // define this in order to do more check for ATV input source.
2701 input1 = input;
2702
2703 HALAUDIO_CHECK_SHM_INIT;
2704
2705 if((input == AUDIO_NULL_INPUT) || (u8Path ==AUDIO_PATH_NULL))
2706 {
2707 return;
2708 }
2709
2710 u8input_src = LONIBBLE(input);
2711 u8input_idx = HINIBBLE(input);
2712
2713 if( u8Path == AUDIO_PATH_MAIN )
2714 {
2715 if (u8input_src == AUDIO_ADC_INPUT || u8input_src == AUDIO_ADC2_INPUT)
2716 {
2717 HAL_SOUND_EnableDcRemove(TRUE);
2718 }
2719 else
2720 {
2721 HAL_SOUND_EnableDcRemove(FALSE);
2722 }
2723 }
2724
2725 path=(MS_U8)u8Path;
2726
2727 /* save main speaker audio input */
2728 if( u8Path == AUDIO_PATH_MAIN )
2729 {
2730 g_AudioVars2->AudioSrcType = input1;
2731 }
2732 /* save sub channel audio input */
2733 else if( u8Path == AUDIO_PATH_6 )
2734 {
2735 g_AudioVars2->AudioSubSrcType = input1;
2736 }
2737
2738 if( path >= (sizeof(u32PathArray)/sizeof(u32PathArray[0])))
2739 {
2740 DBG_AUDIO(printf("DSP is not support more than CH8\n"));
2741 return;
2742 }
2743
2744 u32path_reg = u32PathArray[path];
2745
2746 // Set input
2747 switch(u8input_src)
2748 {
2749 case AUDIO_DSP1_INPUT:
2750 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x80);
2751 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG, 0x07,u8input_idx);
2752 break;
2753
2754 case AUDIO_DSP2_INPUT:
2755 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x81);
2756 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx);
2757 break;
2758
2759 case AUDIO_DSP3_INPUT:
2760 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x82);
2761 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x07,u8input_idx);
2762 break;
2763
2764 case AUDIO_DSP4_INPUT:
2765 /*
2766 * A patch here!
2767 * Just a temporary solution to hardcode channel 7 to 0x90 for HW DMA Reader2,
2768 */
2769 if (u8input_idx == 0x7)
2770 {
2771 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x83);
2772 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER4_CFG, 0x07,u8input_idx);
2773 } else {
2774 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x90);
2775 }
2776 break;
2777
2778 case AUDIO_ADC_INPUT:
2779 if(u8input_idx==0x0A)
2780 u8temp=0x40;
2781 else if(u8input_idx==0x0B)
2782 u8temp=0x50;
2783 else
2784 u8temp = (u8input_idx<<4);
2785 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x88);
2786 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, u8temp );
2787 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00 ); //disable power down INMUX
2788 break;
2789
2790 case AUDIO_ADC2_INPUT:
2791 if(u8input_idx==0x0A)
2792 u8temp=0x04;
2793 else if(u8input_idx==0x0B)
2794 u8temp=0x05;
2795 else
2796 u8temp = u8input_idx;
2797 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x89);
2798 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp );
2799 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00 ); //disable power down INMUX
2800 break;
2801
2802 case AUDIO_SPDIF_INPUT:
2803 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x86);
2804 break;
2805
2806 case AUDIO_I2S_INPUT:
2807 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x85);
2808 break;
2809
2810 case AUDIO_HDMI_INPUT:
2811 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x84);
2812 break;
2813
2814 case AUDIO_DMA_INPUT:
2815 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x8F);
2816 break;
2817
2818 default:
2819 break;
2820 }
2821
2822 }
2823
2824 ////////////////////////////////////////////////////////////////////////////////
2825 /// @brief \b Function \b Name: HAL_AUDIO_SetOutputPath() @@Need_Modify
2826 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2827 /// @param <IN> \b u8Path : Audio DSP channel
2828 /// @param <IN> \b output : Audio output type
2829 /// @param <OUT> \b NONE :
2830 /// @param <RET> \b NONE :
2831 /// @param <GLOBAL> \b NONE :
2832 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2833 void HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2834 {
2835 u8Path=u8Path;
2836 u8Output=u8Output;
2837 }
2838
2839 ////////////////////////////////////////////////////////////////////////////////
2840 /// @brief \b Function \b Name: HAL_AUDIO_SetInternalPath() @@VVV
2841 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2842 /// @param <IN> \b u8Path : Audio internal path
2843 /// @param <IN> \b output : Audio output type
2844 /// @param <OUT> \b NONE :
2845 /// @param <RET> \b NONE :
2846 /// @param <GLOBAL> \b NONE :
2847 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2848 void HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2849 {
2850 MS_U8 path;
2851 // OUT0, OUT1, OUT2 , OUT3 , S/PDIF, I2S, HP , Dummy, Dummy, HDMI
2852 MS_U8 BalanceBitMap[10]={ 0, 1, 2, 3, 5, 4, 1, 7, 7, 10 };
2853
2854 if(u8Path >= INTERNAL_MAX_NUM)
2855 return;
2856
2857 path = (MS_U8)u8Path;
2858
2859 if(u8Path==INTERNAL_PCM_SE) // Only speaker use this path
2860 {
2861 g_BalanceMask=g_BalanceMask|(0x01<<BalanceBitMap[(int)u8Output]); // Enable balance mask
2862 }
2863
2864 if((HAL_AUDIO_ReadByte(M2S_MBOX_BALANCE_EN+1)&0x80)!=0)
2865 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
2866 else
2867 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000); // Balance disable
2868
2869 // Set output
2870 switch(u8Output)
2871 {
2872 case AUDIO_AUOUT0_OUTPUT:
2873 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0x0F, path);
2874 break;
2875
2876 case AUDIO_AUOUT1_OUTPUT:
2877 case AUDIO_HP_OUTPUT:
2878 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0xF0, (path<<4));
2879 break;
2880
2881 case AUDIO_AUOUT2_OUTPUT:
2882 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0x0F, path);
2883 break;
2884
2885 case AUDIO_AUOUT3_OUTPUT:
2886 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0xF0, (path<<4));
2887 break;
2888
2889 case AUDIO_I2S_OUTPUT:
2890 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0x0F, path);
2891 break;
2892
2893 case AUDIO_SPDIF_OUTPUT:
2894 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3+1, 0x0F, path); // Fix PCM in
2895 break;
2896
2897 case AUDIO_HDMI_OUTPUT:
2898 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3, 0x0F, path);
2899 break;
2900 case AUDIO_I2S2_OUTPUT:
2901 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0xF0, (path<<4));
2902 break;
2903
2904 default:
2905 break;
2906 }
2907 }
2908
2909
2910 ////////////////////////////////////////////////////////////////////////////////
2911 /// @brief \b Function \b Name: HAL_AUDIO_FwTriggerDSP() @@Need_Modify
2912 /// @brief \b Function \b Description: This routine send a PIO11 interrupt to DSP with a command on 0x2D34.
2913 /// @param <IN> \b cmd : 0xF0-- for MHEG5 file protocol
2914 /// @param <OUT> \b NONE :
2915 /// @param <RET> \b NONE :
2916 /// @param <GLOBAL> \b NONE :
2917 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd)2918 void HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd) //Cathy need modify
2919 {
2920 u16Cmd = u16Cmd;
2921 }
2922
2923 ////////////////////////////////////////////////////////////////////////////////
2924 /// @brief \b Function \b Name: HAL_AUDIO_DspBootOnDDR()
2925 /// @brief \b Function \b Description: Enable DSP load / reload code from DDR
2926 /// @param <IN> \b bEnable : 0 -- load code from FLASH
2927 /// 1 -- load code from DDR
2928 /// @param <OUT> \b NONE :
2929 /// @param <RET> \b NONE :
2930 /// @param <GLOBAL> \b NONE :
2931 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)2932 void HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)
2933 {
2934 g_bAudio_loadcode_from_dram = bEnable;
2935 }
2936
2937 ////////////////////////////////////////////////////////////////////////////////
2938 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
2939 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
2940 /// @param <IN> \b NONE :
2941 /// @param <OUT> \b NONE :
2942 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
2943 /// @param <GLOBAL> \b NONE :
2944 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetIsDtvFlag(void)2945 MS_BOOL HAL_AUDIO_GetIsDtvFlag(void)
2946 {
2947 return g_bIsDTV;
2948 }
2949
2950 ////////////////////////////////////////////////////////////////////////////////
2951 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
2952 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
2953 /// @param <IN> \b NONE :
2954 /// @param <OUT> \b NONE :
2955 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
2956 /// @param <GLOBAL> \b NONE :
2957 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)2958 void HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)
2959 {
2960 g_bIsDTV=bIsDTV;
2961 }
2962
2963 ////////////////////////////////////////////////////////////////////////////////
2964 /// @brief \b Function \b Name: HAL_AUDIO_Dec_Status() @@Cathy
2965 /// @brief \b Function \b Description: This routine is used to read the Decoder status.
2966 /// @param <IN> \b NONE :
2967 /// @param <OUT> \b NONE :
2968 /// @param <RET> \b MS_U8 : Decoder Status
2969 /// @param <GLOBAL> \b NONE :
2970 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Dec_Status(void)2971 MS_U8 HAL_AUDIO_Dec_Status(void)
2972 {
2973 return(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD));
2974 }
2975
2976 ////////////////////////////////////////////////////////////////////////////////
2977 /// @brief \b Function \b Name: HAL_AUDIO_Enc_Status() @@Kochien.Kuo
2978 /// @brief \b Function \b Description: This routine is used to read the Encoder status.
2979 /// @param <IN> \b NONE :
2980 /// @param <OUT> \b NONE :
2981 /// @param <RET> \b MS_U8 : Encoder Status
2982 /// @param <GLOBAL> \b NONE :
2983 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Enc_Status(void)2984 MS_U8 HAL_AUDIO_Enc_Status(void)
2985 {
2986 return(HAL_AUDIO_ReadByte(REG_DEC_ENCODE_CMD));
2987 }
2988
2989 ////////////////////////////////////////////////////////////////////////////////
2990 /// @brief \b Function \b Name: HAL_AUDIO_SE_Status() @@Cathy
2991 /// @brief \b Function \b Description: This routine is used to read the SE status.
2992 /// @param <IN> \b NONE :
2993 /// @param <OUT> \b NONE :
2994 /// @param <RET> \b MS_U8 : Decoder Status
2995 /// @param <GLOBAL> \b NONE :
2996 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Se_Status(void)2997 MS_U8 HAL_AUDIO_Se_Status(void)
2998 {
2999 return(HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD));
3000 }
3001
3002 ////////////////////////////////////////////////////////////////////////////////
3003 /// @brief \b Function \b Name: HAL_AUDIO_Set_Fading() @@Need_Modify
3004 /// @brief \b Function \b Description: This routine is used to set the Fading response time
3005 /// @param <IN> \b u32VolFading : Fading response time parameter
3006 /// @param <OUT> \b NONE :
3007 /// @param <RET> \b NONE :
3008 /// @param <GLOBAL> \b NONE :
3009 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)3010 void HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)
3011 {
3012 u32VolFading = u32VolFading;
3013 }
3014
3015
3016 ////////////////////////////////////////////////////////////////////////////////
3017 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetUploadRate() @@Need_Modify
3018 /// @brief \b Function \b Description: According Blue tooth upload path, for different sampling rate setting the Synthesizer.
3019 /// @param <IN> \b bEnable : 0 -- Disable Blue Tooth upload
3020 /// 1 -- Enable Blue Tooth upload
3021 /// @param <IN> \b u8Samprate: Sampling Rate
3022 /// 0--no change
3023 /// 1--48KHz
3024 /// 2--44KHz
3025 /// 3--32KHz
3026 /// @param <OUT> \b NONE :
3027 /// @param <RET> \b NONE :
3028 /// @param <GLOBAL> \b NONE :
3029 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)3030 void HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)
3031 {
3032 u8Samprate &= 0x0003;
3033
3034 if(bEnable)
3035 {
3036 HAL_AUDIO_DecWriteByte(0x2C5A, 0x55);
3037 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0x10);
3038 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,u8Samprate);
3039 }
3040 else
3041 {
3042 HAL_AUDIO_DecWriteByte(0x2C5A, 0);
3043 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0);
3044 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,0);
3045 }
3046 }
3047
3048
3049 ////////////////////////////////////////////////////////////////////////////////
3050 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetBufferCounter() @@Need_Modify
3051 /// @brief \b Function \b Description: Set the DDR buffer according the sampling rate and the frame time
3052 /// @param <IN> \b u32Counter : if the sampling rate is 48KHz, the frame time is 40ms
3053 /// ==> the frame buffer size is 48000*0x04*2 (L/R) *2(Bytes/sample) = 0x1E00
3054 /// the counter is 0x1E00/8 = 960 (For 1*Burst DMA)
3055 /// @param <OUT> \b NONE :
3056 /// @param <RET> \b NONE :
3057 /// @param <GLOBAL> \b NONE :
3058 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)3059 void HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)
3060 {
3061 u32Counter &= 0x00FFFFFF;
3062 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_btFrameSize, u32Counter);
3063 }
3064
3065 ////////////////////////////////////////////////////////////////////////////////
3066 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_Enable() @@Need_Modify
3067 /// @brief \b Function \b Description: Enable/ Disable the path of USB PCM
3068 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
3069 /// @param <OUT> \b NONE :
3070 /// @param <RET> \b NONE :
3071 /// @param <GLOBAL> \b NONE :
3072 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)3073 void HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)
3074 {
3075 //this funcion is removed from DSP
3076 UNUSED(bEnable);
3077 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3078 }
3079
3080
3081 ////////////////////////////////////////////////////////////////////////////////
3082 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetFlag() @@Need_Modify
3083 /// @brief \b Function \b Description: Get interrupt flag for USBPCM function
3084 /// \b (Encoder path)
3085 /// @param <IN> \b NONE :
3086 /// @param <OUT> \b NONE :
3087 /// @param <RET> \b BOOL : interrupt flag
3088 /// @param <GLOBAL> \b NONE :
3089 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetFlag()3090 MS_BOOL HAL_AUDIO_USBPCM_GetFlag()
3091 {
3092 //this funcion is removed from DSP
3093 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3094 return 0;
3095 }
3096
3097 ////////////////////////////////////////////////////////////////////////////////
3098 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_SetFlag() @@Need_Modify
3099 /// @brief \b Function \b Description: clear interrupt flag for USBPCM function
3100 /// \b (Encoder path)
3101 /// @param <IN> \b bEnable : set false to clean interrupt flag
3102 /// @param <OUT> \b NONE :
3103 /// @param <RET> \b NONE :
3104 /// @param <GLOBAL> \b NONE :
3105 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)3106 void HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)
3107 {
3108 //this funcion is removed from DSP
3109 UNUSED(bEnable);
3110 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3111 }
3112
3113 ////////////////////////////////////////////////////////////////////////////////
3114 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetMemInfo() @@Need_Modify
3115 /// @brief \b Function \b Description: Get memory address and size for USBPCM function
3116 /// \b (Encoder path)
3117 /// @param <IN> \b NONE :
3118 /// @param <OUT> \b MS_U32 : address, size
3119 /// @param <RET> \b NONE :
3120 /// @param <GLOBAL> \b NONE :
3121 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO * uploadInfo)3122 void HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO *uploadInfo)
3123 {
3124 //this funcion is removed from DSP
3125 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3126 }
3127
3128 ////////////////////////////////////////////////////////////////////////////////
3129 /// @brief \b Function \b Name: HAL_AUDIO_ I2S_SetMode() @@Need_Modify
3130 /// @brief \b Function \b Description: This routine is used to Set the I2S output mode.
3131 /// @param <IN> \b Mode : MCLK , WORD_WIDTH , SOURCE_CH , FORMAT
3132 /// @param <IN> \b Value : Please reference the register table 0x2C8C & 0x2C8D .
3133 /// @param <OUT> \b NONE :
3134 /// @param <RET> \b NONE :
3135 /// @param <GLOBAL> \b NONE :
3136 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode,MS_U8 u8Val)3137 void _HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode, MS_U8 u8Val)
3138 {
3139 switch(u8Mode)
3140 {
3141 case AUDIO_I2S_MCLK: //0x2C8C[6:4]
3142 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x70,u8Val<<4);
3143 break;
3144
3145 case AUDIO_I2S_WORD_WIDTH: //0x2C8C[2:0]
3146 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x07,u8Val);
3147 break;
3148
3149 case AUDIO_I2S_FORMAT: //0x2C8C[3]
3150 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x08,u8Val<<3);
3151 break;
3152
3153 case AUDIO_I2S_SOURCE_CH:
3154 // No need ; Only select Group A in T3 .
3155 break;
3156
3157 default:
3158 break;
3159 };
3160 }
3161
HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType,MS_BOOL bEnable)3162 static void HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType, MS_BOOL bEnable)
3163 {
3164 switch(eType)
3165 {
3166 case DD_DDCO:
3167 if(bEnable == TRUE)
3168 {
3169 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x1 );
3170 }
3171 else
3172 {
3173 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x0 );
3174 }
3175 break;
3176
3177 case DD_DDENCODE:
3178 if(bEnable == TRUE)
3179 {
3180 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x2 );
3181 }
3182 else
3183 {
3184 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x0 );
3185 }
3186 break;
3187
3188 case MP3_ENCODE:
3189 if(bEnable == TRUE)
3190 {
3191 HAL_AUDIO_WriteMaskByte(REG_SOUND_MP3_ENCODE_CTRL, 0x01, 0x1 );
3192 }
3193 else
3194 {
3195 HAL_AUDIO_WriteMaskByte(REG_SOUND_MP3_ENCODE_CTRL, 0x01, 0x0 );
3196 }
3197 break;
3198
3199 case DTS_ENCODE_2CH:
3200 case DTS_ENCODE_MULTI:
3201 default:
3202 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Choosen Encoder not exist\n",__FUNCTION__);
3203 break;
3204 }
3205 }
3206
HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DSP_ID eDspID)3207 static void HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DSP_ID eDspID)
3208 {
3209 switch (ePath)
3210 {
3211 case DIGITAL_SPDIF_OUTPUT:
3212 {
3213 switch(eDspID)
3214 {
3215 case AUDIO_DSP_ID_R2:
3216 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x4);
3217 break;
3218 case AUDIO_DSP_ID_SND:
3219 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x8);
3220 break;
3221 case AUDIO_DSP_ID_DEC:
3222 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x0);
3223 break;
3224 default:
3225 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3226 break;
3227 }
3228 }
3229 break;
3230
3231 case DIGITAL_HDMI_ARC_OUTPUT:
3232 {
3233 switch(eDspID)
3234 {
3235 case AUDIO_DSP_ID_R2:
3236 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3237 break;
3238 case AUDIO_DSP_ID_SND:
3239 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3240 break;
3241 case AUDIO_DSP_ID_DEC:
3242 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3243 break;
3244 default:
3245 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3246 break;
3247 }
3248 }
3249 break;
3250
3251 case DIGITAL_HDMI_OUTPUT:
3252 {
3253 switch(eDspID)
3254 {
3255 case AUDIO_DSP_ID_R2:
3256 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3257 break;
3258 case AUDIO_DSP_ID_SND:
3259 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3260 break;
3261 case AUDIO_DSP_ID_DEC:
3262 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3263 break;
3264 default:
3265 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3266 break;
3267 }
3268 }
3269 break;
3270
3271 default:
3272 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3273 break;
3274 }
3275
3276 }
3277
HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath,MS_BOOL bEnable)3278 static void HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath, MS_BOOL bEnable)
3279 {
3280
3281 switch(ePath)
3282 {
3283 case DIGITAL_SPDIF_OUTPUT:
3284 if(bEnable == TRUE)
3285 {
3286 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
3287 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
3288 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x2);
3289 }
3290 else
3291 {
3292 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select DSP1 */
3293 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
3294 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
3295 }
3296 break;
3297
3298 case DIGITAL_HDMI_ARC_OUTPUT:
3299 if(bEnable == TRUE)
3300 {
3301 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3302 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3303 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3304 }
3305 else
3306 {
3307 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3308 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3309 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3310 }
3311 break;
3312
3313 case DIGITAL_HDMI_OUTPUT:
3314 if(bEnable == TRUE)
3315 {
3316 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3317 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3318 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3319 }
3320 else
3321 {
3322 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3323 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3324 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3325 }
3326 break;
3327
3328 default:
3329 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3330 break;
3331 }
3332 }
3333 ////////////////////////////////////////////////////////////////////////////////
3334 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3335 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3336 /// @param <IN> \b u8Spdif_mode :
3337 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3338 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3339 /// bit[2] = 1: non-PCM NULL Payload
3340 /// @param <IN> \b u8Input_src 0 : DTV
3341 /// 1 : ATV
3342 /// 2 : HDMI
3343 /// 3 : ADC
3344 /// 4 : CardReader
3345 /// 5 : SPDIF
3346 /// @param <OUT> \b NONE :
3347 /// @param <RET> \b NONE :
3348 /// @param <GLOBAL> \b NONE :
3349 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSetting)3350 static void HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSetting)
3351 {
3352 Digital_Out_Channel_Status_t stDigitalChannelStatus;
3353 memset(&stDigitalChannelStatus, 0x00, sizeof(Digital_Out_Channel_Status_t));
3354
3355 if (ePath == DIGITAL_SPDIF_OUTPUT)
3356 {
3357 _HAL_AUDIO_SPDIF_SetMute(TRUE);
3358 }
3359 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3360 {
3361 //TODO: Mute HDMI , ARC
3362 }
3363 else if (ePath == DIGITAL_HDMI_OUTPUT)
3364 {
3365
3366 }
3367
3368 HAL_AUDIO_DigitalOut_GetChannelStatus(ePath, &stDigitalChannelStatus);
3369
3370 switch (stDigitalOutSetting->eDigitalOutfMode)
3371 {
3372 case DIGITAL_OUT_PCM:
3373 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, FALSE);
3374 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3375 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3376
3377 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
3378 break;
3379
3380 case DIGITAL_OUT_DOLBYDIGITAL:
3381 if (stDigitalOutSetting->u8R2NonPcmSetting == 0x01)
3382 {
3383 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3384 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, TRUE);
3385 }
3386 else if (stDigitalOutSetting->u8R2NonPcmSetting == 0x02)
3387 {
3388 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3389 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, TRUE);
3390 }
3391
3392 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3393 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3394 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3395 break;
3396
3397 case DIGITAL_OUT_DTS:
3398 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3399 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3400 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3401 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3402 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3403 break;
3404
3405 case DIGITAL_OUT_AAC_LC:
3406 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3407 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3408 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3409 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3410 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3411 break;
3412
3413 case DIGITAL_OUT_NONE:
3414 default:
3415 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Mode %d not exist\n",__FUNCTION__,stDigitalOutSetting->eDigitalOutfMode);
3416 break;
3417 }
3418
3419 HAL_AUDIO_DigitalOut_SetChannelStatus(ePath, &stDigitalChannelStatus);
3420 // Restore Digital out mode
3421 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), &stDigitalOutSetting, sizeof(stDigitalOutSetting));
3422
3423 if (ePath == DIGITAL_SPDIF_OUTPUT)
3424 {
3425 if (g_AudioVars2->g_SPDIF_MuteStatus == FALSE)
3426 {
3427 _HAL_AUDIO_SPDIF_SetMute(FALSE);
3428 }
3429 }
3430 else
3431 {
3432 //TODO: um-Mute HDMI , ARC
3433 }
3434
3435 }
3436
3437
3438
3439 //static MS_BOOL HAL_AUDIO_DigitalOut_GetDataSource(AUDIO_OUTPORT_SOURCE_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE *retOutputType, AUDIO_DSP_ID *retNcmPath)
3440
HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSegtting)3441 static MS_BOOL HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSegtting)
3442 {
3443 MS_U8 u8SourceDspCodeType = AU_DVB_STANDARD_INVALID;
3444 MS_U8 u8Dsp1CodeType = AU_DVB_STANDARD_INVALID;
3445 MS_U8 u8Dsp2CodeType = AU_DVB_STANDARD_INVALID;
3446
3447 stDigitalOutSegtting->eSourceType = g_AudioVars2->eAudioSource;
3448 u8Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3449 u8Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3450
3451 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x , Source = %x, R2NonPcmSetting = %x\n\r", \
3452 __FUNCTION__, \
3453 stDigitalOutSegtting->eDigitalOutfMode, \
3454 stDigitalOutSegtting->u8NonPcmPath, \
3455 stDigitalOutSegtting->eSourceType, \
3456 stDigitalOutSegtting->u8R2NonPcmSetting);
3457
3458 switch (stDigitalOutSegtting->eDigitalOutfMode)
3459 {
3460 case DIGITAL_OUT_PCM:
3461 {
3462 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3463 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC;
3464 break;
3465 }
3466
3467 case DIGITAL_OUT_DOLBYDIGITAL:
3468 {
3469 switch (stDigitalOutSegtting->eSourceType)
3470 {
3471 case E_AUDIO_INFO_HDMI_IN:
3472 {
3473 if (bIsNonPCMInDec2)
3474 {
3475 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) &&
3476 (u8Dsp2CodeType == AU_DVB2_STANDARD_AC3P_AD))
3477 {
3478 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3479 }
3480 }
3481 else if ((u8Dsp1CodeType == AU_DVB_STANDARD_AC3) ||
3482 (u8Dsp1CodeType == AU_DVB_STANDARD_AC3P))
3483 {
3484 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3485 }
3486 break;
3487 }
3488
3489 case E_AUDIO_INFO_DTV_IN:
3490 case E_AUDIO_INFO_MM_IN:
3491 case E_AUDIO_INFO_GAME_IN:
3492 {
3493 u8SourceDspCodeType = u8Dsp1CodeType;
3494
3495 switch(u8SourceDspCodeType)
3496 {
3497 case AU_DVB_STANDARD_AAC:
3498 case AU_DVB_STANDARD_MS10_DDT:
3499 {
3500 #ifndef CONFIG_MBOOT //Add For GPL (content protection)
3501 if ((!MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_MS10_DDT)) &&
3502 (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DDE)))
3503 {
3504 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3505 }
3506 else
3507 {
3508 if (HAL_MAD_Read_DSP_sram(DSP1PmAddr_smpRate, DSP_MEM_TYPE_PM) == 44100)
3509 {
3510 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3511 }
3512 else
3513 {
3514 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_R2; /* R2 */
3515 stDigitalOutSegtting->u8R2NonPcmSetting = (u8SourceDspCodeType == AU_DVB_STANDARD_AAC) ? 0x01 : 0x02; /* DDCO : 0x2E95[0], DDEnc : 0x2E95[1] */
3516 }
3517 }
3518 #else
3519 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3520 #endif //End of GPL contect protection
3521
3522 break;
3523 }
3524
3525 case AU_DVB_STANDARD_MS10_DDC:
3526 case AU_DVB_STANDARD_AC3:
3527 case AU_DVB_STANDARD_AC3P:
3528 {
3529 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3530 break;
3531 }
3532
3533 default:
3534 {
3535 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3536 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3537 break;
3538 }
3539
3540 }
3541
3542 break;
3543 }
3544
3545 case E_AUDIO_INFO_ATV_IN:
3546 case E_AUDIO_INFO_ADC_IN:
3547 case E_AUDIO_INFO_KTV_IN:
3548 default:
3549 {
3550 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3551 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3552 break;
3553 }
3554 }
3555 break;
3556 }
3557
3558 case DIGITAL_OUT_DTS:
3559 {
3560 switch (stDigitalOutSegtting->eSourceType)
3561 {
3562 case E_AUDIO_INFO_HDMI_IN:
3563 {
3564 if (bIsNonPCMInDec2)
3565 {
3566 if (u8Dsp2CodeType == AU_DVB2_STANDARD_DTS) // Need check
3567 {
3568 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3569 }
3570 }
3571 else if (u8Dsp1CodeType == AU_DVB_STANDARD_DTS)
3572 {
3573 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3574 }
3575 break;
3576 }
3577
3578 case E_AUDIO_INFO_MM_IN:
3579 case E_AUDIO_INFO_GAME_IN:
3580 {
3581 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_DTS;
3582 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3583 break;
3584 }
3585
3586 default:
3587 {
3588 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3589 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3590 break;
3591 }
3592 }
3593
3594 break;
3595 }
3596
3597 case DIGITAL_OUT_AAC_LC:
3598 {
3599 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3600 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3601 break;
3602 }
3603
3604 case DIGITAL_OUT_NONE:
3605 default:
3606 {
3607 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3608 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3609 break;
3610 }
3611
3612 }
3613
3614 return TRUE;
3615 }
3616
3617 ////////////////////////////////////////////////////////////////////////////////
3618 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3619 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3620 /// @param <IN> \b
3621 /// @param <IN> \b
3622 /// @param <OUT> \b NONE :
3623 /// @param <RET> \b NONE :
3624 /// @param <GLOBAL> \b NONE :
3625 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)3626 void HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)
3627 {
3628
3629 HALAUDIO_CHECK_SHM_INIT;
3630
3631 //TODO: add HDMI/ARC digital out status
3632
3633 // Set Digital mode to Digital out Status structure
3634 DigitalOutSetting_t stTempDigitalOutStatus;
3635 stTempDigitalOutStatus.eDigitalOutfMode = eDigitalMode;
3636 stTempDigitalOutStatus.eSourceType = E_AUDIO_INFO_DTV_IN; // Temp initial value
3637 stTempDigitalOutStatus.u8NonPcmPath = AUDIO_DSP_ID_ALL;
3638 stTempDigitalOutStatus.u8R2NonPcmSetting = 0x00;
3639 stTempDigitalOutStatus.eGroup = E_CONNECT_NULL;
3640
3641 if (ePath == DIGITAL_SPDIF_OUTPUT)
3642 {
3643 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.SpdifOut;
3644 }
3645 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3646 {
3647 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.ArcOut;
3648 }
3649
3650 //Determin Data Path
3651 HAL_AUDIO_DigitalOut_DetermineDataPath(ePath, &stTempDigitalOutStatus);
3652
3653 // if setting is difference to previous, set digital out mode
3654 if ((stTempDigitalOutStatus.eDigitalOutfMode != g_AudioVars2->stDigitalOutSetting[ePath].eDigitalOutfMode) ||
3655 (stTempDigitalOutStatus.eSourceType != g_AudioVars2->stDigitalOutSetting[ePath].eSourceType) ||
3656 (stTempDigitalOutStatus.u8NonPcmPath != g_AudioVars2->stDigitalOutSetting[ePath].u8NonPcmPath) ||
3657 (stTempDigitalOutStatus.u8R2NonPcmSetting != g_AudioVars2->stDigitalOutSetting[ePath].u8R2NonPcmSetting) ||
3658 (stTempDigitalOutStatus.eGroup != g_AudioVars2->stDigitalOutSetting[ePath].eGroup))
3659
3660 {
3661 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x\n\r", \
3662 __FUNCTION__, \
3663 stTempDigitalOutStatus.eDigitalOutfMode, \
3664 stTempDigitalOutStatus.u8NonPcmPath);
3665
3666 HAL_AUDIO_DigitalOut_SetDataPath(ePath, &stTempDigitalOutStatus);
3667 }
3668 }
3669
3670 ////////////////////////////////////////////////////////////////////////////////
3671 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3672 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3673 /// @param <IN> \b eType :
3674 /// @param <OUT> \b NONE :
3675 /// @param <RET> \b NONE :
3676 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3677 MS_BOOL HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3678 {
3679 MS_BOOL ret = FALSE;
3680
3681 HALAUDIO_CHECK_SHM_INIT;
3682
3683 switch (ePath)
3684 {
3685 case DIGITAL_SPDIF_OUTPUT:
3686 {
3687
3688 // Copy protection
3689 //C bit
3690 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3691 // L bit
3692 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3693
3694 // PCM format
3695 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3696 if(g_u32bDTSCD == 1)
3697 {
3698 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x40, 0x00);
3699 }
3700
3701 // Category
3702 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3703
3704 // Source number
3705 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3706
3707 // Channel number
3708 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3709
3710 // Sampling rate
3711 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3712
3713 // Clock precision
3714 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3715
3716 // Word Length
3717 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3718
3719 // Original sampling rate
3720 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3721
3722 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3723 {
3724 if(g_u32bDTSCD == 1)
3725 {
3726 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3727 }
3728 else
3729 {
3730 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x80);
3731 }
3732 }
3733 else
3734 {
3735 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3736 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3737 }
3738
3739 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00); //Tx1 Toggle bit[14]
3740 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x40);
3741 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00);
3742 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3743 break;
3744 }
3745
3746 case DIGITAL_HDMI_ARC_OUTPUT:
3747 {
3748 // Copy protection
3749 //C bit
3750 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3751 // L bit
3752 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3753
3754 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3755 if(g_u32bDTSCD == 1)
3756 {
3757 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x40, 0x00);
3758 }
3759
3760 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3761
3762 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3763
3764 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3765
3766 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3767
3768 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3769
3770 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3771
3772 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3773
3774 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3775 {
3776 if(g_u32bDTSCD == 1)
3777 {
3778 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3779 }
3780 else
3781 {
3782 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x80);
3783 }
3784 }
3785 else
3786 {
3787 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3788 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3789 }
3790 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3791 break;
3792 }
3793
3794 default:
3795 {
3796 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Invalid SPDIF Path\n",__FUNCTION__);
3797 break;
3798 }
3799 }
3800
3801 return ret;
3802 }
3803
3804 ////////////////////////////////////////////////////////////////////////////////
3805 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3806 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3807 /// @param <IN> \b eType :
3808 /// @param <OUT> \b NONE :
3809 /// @param <RET> \b NONE :
3810 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3811 MS_BOOL HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3812 {
3813 MS_BOOL ret = FALSE;
3814
3815 HALAUDIO_CHECK_SHM_INIT;
3816
3817 if (stChannelStatus == NULL)
3818 {
3819 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : stChannelStatus shouldn't be NULL !!!\n", __FUNCTION__);
3820 }
3821 else
3822 {
3823 memcpy(stChannelStatus, &(g_AudioVars2->stDigitalOutChannelStatus[ePath]), sizeof(Digital_Out_Channel_Status_t));
3824 ret = TRUE;
3825 }
3826
3827 return ret;
3828 }
3829
3830 ///-----------------------------------------------------------------------------
3831 ////////////////////////////////////////////////////////////////////////////////
3832 ////////////////////////////////////////////////////////////////////////////////
3833 ///
3834 /// AUDIO SPDIF Relational Hal Function
3835 ///
3836 ////////////////////////////////////////////////////////////////////////////////
3837 ////////////////////////////////////////////////////////////////////////////////
3838 ///-----------------------------------------------------------------------------
3839 ////////////////////////////////////////////////////////////////////////////////
3840 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_HWEN() @@Cathy
3841 /// @brief \b Function \b Description: This routine is used to enable S/PDIF output (Hardware)
3842 /// @param <IN> \b bEnable: 0--Disable S/PDIF out
3843 /// 1--Enable S/PDIF out
3844 /// @param <OUT> \b NONE :
3845 /// @param <RET> \b NONE :
3846 /// @param <GLOBAL> \b NONE :
3847 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)3848 void _HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)
3849 {
3850 if(bEnable)
3851 {
3852 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x80);
3853 }
3854 else
3855 {
3856 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00);
3857 }
3858 }
3859
3860 ////////////////////////////////////////////////////////////////////////////////
3861 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_SetMute() @@KH
3862 /// @brief \b Function \b Description: This routine is used to mute S/PDIF output(by DSP)
3863 /// @param <IN> \b bEnMute : 0--Disable mute
3864 /// 1--Enable mute
3865 /// @param <OUT> \b NONE :
3866 /// @param <RET> \b NONE :
3867 /// @param <GLOBAL> \b NONE :
3868 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)3869 void _HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)
3870 {
3871 MS_BOOL spdif_mute_status = FALSE;
3872 MS_U8 spdif_timecnt = 0;
3873
3874 HALAUDIO_CHECK_SHM_INIT;
3875
3876 /* check current status according to SPDIF Software mute bit */
3877 spdif_mute_status = (((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL) & 0x01) > 0) ? TRUE : FALSE);
3878
3879 /* apply change only when it's a different status from current status */
3880 if (spdif_mute_status != bEnMute)
3881 {
3882 if (bEnMute == TRUE)
3883 {
3884 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
3885 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x01); // Software mute
3886 }
3887 else
3888 {
3889 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x00); // Software unmute
3890 for (spdif_timecnt = 0; spdif_timecnt < 30; spdif_timecnt++)
3891 {
3892 AUDIO_DELAY1MS(1);
3893 }
3894 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
3895 }
3896 }
3897 }
3898
3899 ////////////////////////////////////////////////////////////////////////////////
3900 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_ByPassChannel() @@Need_Modify
3901 /// @brief \b Function \b Description: ByPass the SPDIF channel (CH4)
3902 /// @param <IN> \b \b enable : TRUE --BYPASS CH4
3903 /// FALSE--OPEN CH4
3904 /// @param <OUT> \b NONE :
3905 /// @param <RET> \b NONE :
3906 /// @param <GLOBAL> \b NONE :
3907 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)3908 void _HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)
3909 {
3910 bEnable = bEnable;
3911 }
3912
3913 ////////////////////////////////////////////////////////////////////////////////
3914 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3915 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3916 /// @param <IN> \b u8Spdif_mode :
3917 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3918 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3919 /// bit[2] = 1: non-PCM NULL Payload
3920 /// @param <IN> \b u8Input_src 0 : DTV
3921 /// 1 : ATV
3922 /// 2 : HDMI
3923 /// 3 : ADC
3924 /// 4 : CardReader
3925 /// 5 : SPDIF
3926 /// @param <OUT> \b NONE :
3927 /// @param <RET> \b NONE :
3928 /// @param <GLOBAL> \b NONE :
3929 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode,MS_U8 u8Input_src)3930 void HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode, MS_U8 u8Input_src)
3931 {
3932 // Multiple npcm source, still need total rework
3933 AUDIO_SOURCE_INFO_TYPE eAudioSource = -1;
3934 MS_U8 u8SpdifMode = ((u8Spdif_mode == SPDIF_OUT_NONE) ? SPDIF_OUT_PCM : u8Spdif_mode);
3935 MS_U8 u8R2SpdifMode = ((u8SpdifMode == SPDIF_OUT_PCM) ? 1 : 2);
3936 MS_U8 u8MainDspCodeType = MSAPI_AUD_DVB_INVALID;
3937 MS_U8 u8Dsp1CodeType = MSAPI_AUD_DVB_INVALID;
3938 MS_U8 u8Dsp2CodeType = MSAPI_AUD_DVB_INVALID;
3939 MS_U32 u32bDTSCD = 0;
3940 MS_U8 u8NonPcmPath = ADEC1; /* R2: ADEC1, ADEC2 */
3941
3942 HALAUDIO_CHECK_SHM_INIT;
3943 static MS_U32 u32bPreDTSCD = 0xFF;
3944 UNUSED(u8Input_src);
3945 eAudioSource = g_AudioVars2->eAudioSource;
3946 u8Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3947 u8Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3948
3949 u8MainDspCodeType = u8Dsp1CodeType;
3950 u8NonPcmPath = ADEC1;
3951 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: u8Spdif_mode = %d, eAudioSource = %d, u8Dsp1CodeType = %d, u8Dsp2CodeType = %d, u8Input_src = %d\r\n", __FUNCTION__, u8Spdif_mode, eAudioSource, u8Dsp1CodeType, u8Dsp2CodeType, u8Input_src);
3952
3953 /* Configure SPDIF's Output Setting */
3954 switch(eAudioSource)
3955 {
3956 case E_AUDIO_INFO_DTV_IN:
3957 case E_AUDIO_INFO_MM_IN:
3958 case E_AUDIO_INFO_GAME_IN:
3959 {
3960 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
3961 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
3962 {
3963 u8MainDspCodeType = u8Dsp2CodeType;
3964 u8NonPcmPath = ADEC2; //DEC2
3965 }
3966 else
3967 {
3968 if (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_STOP)
3969 {
3970 u8SpdifMode = SPDIF_OUT_PCM;
3971 break;
3972 }
3973 }
3974
3975
3976
3977 switch(u8MainDspCodeType)
3978 {
3979 case AU_DVB_STANDARD_AAC:
3980 case AU_DVB_STANDARD_MS10_DDT:
3981 {
3982 if (g_AudioVars2->DolbyEncFlag != 1)
3983 {
3984 u8SpdifMode = SPDIF_OUT_PCM;
3985 }
3986 #if (StereoAACOutputPCM)
3987 else if (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod) == AUD_CH_MODE_STEREO)
3988 {
3989 u8SpdifMode = SPDIF_OUT_PCM;
3990 }
3991 #endif
3992 else
3993 {
3994 if ((u8SpdifMode == SPDIF_OUT_NONPCM) ||
3995 (u8SpdifMode == SPDIF_OUT_TRANSCODE))
3996 {
3997 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, AU_DEC_ID1, 0, 0);
3998 }
3999 else if (u8SpdifMode == SPDIF_OUT_BYPASS) // AAC Bypass
4000 {
4001 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, AU_DEC_ID1, 1, 0);
4002 }
4003 }
4004 break;
4005 }
4006
4007 case AU_DVB_STANDARD_AC3:
4008 case AU_DVB_STANDARD_AC3P:
4009 case AU_DVB_STANDARD_MS10_DDC:
4010 {
4011 break;
4012 }
4013 case AU_DVB_STANDARD_DTS:
4014 {
4015 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4016 break;
4017 }
4018
4019 case AU_DVB_STANDARD_DTSLBR:
4020 {
4021 #ifndef CONFIG_MBOOT //Add For GPL (content protection)
4022 if (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DTSE))
4023 #endif //End of GPL contect protection
4024 {
4025 u8SpdifMode = SPDIF_OUT_PCM;
4026 }
4027 break;
4028 }
4029
4030 case AU_DEC_ES_BYPASS:
4031 break;
4032
4033 case AU_DVB_STANDARD_DolbyTrueHD_Bypass:
4034 break;
4035
4036 default:
4037 {
4038 u8SpdifMode = SPDIF_OUT_PCM;
4039 break;
4040 }
4041 }
4042
4043 break;
4044 }
4045
4046 case E_AUDIO_INFO_ATV_IN:
4047 case E_AUDIO_INFO_ADC_IN:
4048 case E_AUDIO_INFO_KTV_IN:
4049 {
4050 u8SpdifMode = SPDIF_OUT_PCM;
4051 break;
4052 }
4053
4054 case E_AUDIO_INFO_HDMI_IN:
4055 {
4056 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
4057 {
4058 u8MainDspCodeType = u8Dsp2CodeType;
4059 u8NonPcmPath = ADEC2; //DEC2
4060 }
4061 else
4062 {
4063 u8MainDspCodeType = u8Dsp1CodeType;
4064 u8NonPcmPath = ADEC1; //DEC1
4065 }
4066
4067 if (u8Dsp1CodeType == AU_DVB_STANDARD_DTS)
4068 {
4069 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4070 }
4071
4072 if (HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE)
4073 {
4074 u8SpdifMode = SPDIF_OUT_PCM;
4075 }
4076
4077 break;
4078 }
4079
4080 default:
4081 {
4082 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
4083 break;
4084 }
4085 }
4086
4087 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: u8MainDspCodeType = %d, u8SpdifMode = %d\r\n", __FUNCTION__, u8MainDspCodeType, u8SpdifMode);
4088
4089 if ((_HAL_AUDIO_SPDIF_GetMode() == u8SpdifMode) &&
4090 (u32bPreDTSCD == u32bDTSCD))
4091 {
4092 return;
4093 }
4094 u32bPreDTSCD = u32bDTSCD;
4095
4096 //Change multi channel input source for DTS encode
4097 if( (eAudioSource == E_AUDIO_INFO_HDMI_IN) && (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) )
4098 {
4099 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x02);
4100 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x02);
4101 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x02);
4102 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x02);
4103 }
4104 else
4105 {
4106 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x00);
4107 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x00);
4108 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x00);
4109 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x00);
4110 }
4111
4112 MS_BOOL retTx1, retTx2;
4113 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4114 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4115 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4116 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4117 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4118
4119 if (retTx1 == FALSE || retTx2 == FALSE)
4120 {
4121 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
4122 return;
4123 }
4124
4125 /* Mute SPDIF before changing setting */
4126 _HAL_AUDIO_SPDIF_SetMute(TRUE);
4127
4128 /* Apply UI's SPDIF setting to Audio R2 */
4129 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, AU_DEC_ID1, u8R2SpdifMode, 0);
4130 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, AU_DEC_ID3, u8R2SpdifMode, 0);
4131
4132 /* Apply SPDIF's Output Setting */
4133 switch (u8SpdifMode)
4134 {
4135 case SPDIF_OUT_NONPCM:
4136 case SPDIF_OUT_BYPASS:
4137 case SPDIF_OUT_TRANSCODE:
4138 {
4139 //HALAUDIO_PRINT("HAL SPDIF set as Non-PCM\n");
4140
4141 HAL_AUR2_WriteMaskByte(REG_R2_HDMI_NONPCM_PATH, 0x01, u8NonPcmPath);
4142 AUDIO_DELAY1MS(5);
4143 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
4144 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
4145 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4146 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4147 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4148 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4149 AUDIO_DELAY1MS(5);
4150 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x02, 0x02); /* Non-PCM */
4151
4152 if (u8SpdifMode == SPDIF_OUT_TRANSCODE)
4153 {
4154 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID1, TRUE, 0);
4155 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID3, TRUE, 0);
4156 }
4157 else
4158 {
4159 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID1, FALSE, 0);
4160 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, AU_DEC_ID3, FALSE, 0);
4161 }
4162
4163 break;
4164 }
4165
4166 case SPDIF_OUT_PCM:
4167 default:
4168 {
4169 //HALAUDIO_PRINT("HAL SPDIF set as PCM\n");
4170
4171 AUDIO_DELAY1MS(5);
4172 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
4173 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
4174 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4175 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4176 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4177
4178 break;
4179 }
4180 }
4181
4182 g_u32bDTSCD = u32bDTSCD;
4183
4184 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4185 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4186
4187 g_AudioVars2->g_eSpdifOutputType = u8SpdifMode;
4188 _HAL_AUDIO_SPDIF_SetMute(g_AudioVars2->g_SPDIF_MuteStatus);
4189 }
4190
4191 ////////////////////////////////////////////////////////////////////////////////
4192 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_GetMode() @@KH
4193 /// @brief \b Function \b Description: This routine is used to get S/PDIF mode.
4194 /// @param <IN> \b NONE :
4195 /// @param <OUT> \b NONE :
4196 /// @param <RET> \b BYTE : Se-DSP REG_M2D_MAILBOX_SPDIF_CTRL value
4197 /// u8Spdif_mode = 0x0 : SPDIF enable, PCM mode
4198 /// u8Spdif_mode = 0x1 : SPDIF OFF
4199 /// u8Spdif_mode = 0x2 : SPDIF enable, non-PCM mode
4200 /// @param <GLOBAL> \b NONE :
4201 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_GetMode(void)4202 MS_U8 _HAL_AUDIO_SPDIF_GetMode(void)
4203 {
4204 return g_AudioVars2->g_eSpdifOutputType;
4205 }
4206
4207 ////////////////////////////////////////////////////////////////////////////////
4208 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetSCMS()
4209 /// @brief \b Function \b Description: This routine is used to set SPDIF SCMS.
4210 /// @param C_bit_en \b : copy right control bit, register in 0x2C80[5]
4211 /// @param L_bit_en \b : generation bit, register in 0x2C82[7]
4212 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en,MS_U8 L_bit_en)4213 void HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en, MS_U8 L_bit_en)
4214 {
4215 MS_BOOL retTx1, retTx2;
4216
4217 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4218 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4219 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4220 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4221 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4222
4223 if (retTx1 == TRUE && retTx2 == TRUE)
4224 {
4225 stDigitalChannelStatusTx1.stCopyRight.CBit = C_bit_en;
4226 stDigitalChannelStatusTx1.stCopyRight.LBit = L_bit_en;
4227 stDigitalChannelStatusTx2.stCopyRight.CBit = C_bit_en;
4228 stDigitalChannelStatusTx2.stCopyRight.LBit = L_bit_en;
4229 }
4230 else
4231 {
4232 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
4233 return;
4234 }
4235
4236 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4237 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4238 }
4239
4240 ////////////////////////////////////////////////////////////////////////////////
4241 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_GetSCMS()
4242 /// @brief \b Function \b Description: This routine is used to get SPDIF SCMS.
4243 /// @return MS_U8 \b : SCMS[0] = C bit status, SCMS[1] = L bit status
4244 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_GetSCMS(void)4245 MS_U8 HAL_AUDIO_SPDIF_GetSCMS(void)
4246 {
4247
4248 MS_U8 SCMS_status, SCMS_C_bit_tmp, SCMS_L_bit_tmp;
4249
4250 HALAUDIO_CHECK_SHM_INIT;
4251
4252 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.CBit)
4253 {
4254 SCMS_C_bit_tmp = 0x01;
4255 }
4256 else
4257 {
4258 SCMS_C_bit_tmp = 0x00;
4259 }
4260
4261 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.LBit)
4262 {
4263 SCMS_L_bit_tmp = 0x02;
4264 }
4265 else
4266 {
4267 SCMS_L_bit_tmp = 0x00;
4268 }
4269
4270 SCMS_status = SCMS_C_bit_tmp | SCMS_L_bit_tmp;
4271
4272 return(SCMS_status);
4273 }
4274
4275 ////////////////////////////////////////////////////////////////////////////////
4276 /// @brief \b Function \b Name: HAL_AUDIO_SetChannelStatus()
4277 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4278 /// @param <IN> \b eType :
4279 /// @param <OUT> \b NONE :
4280 /// @param <RET> \b NONE :
4281 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType,SPDIF_CS_MODE_VALUE eValue)4282 void HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType, SPDIF_CS_MODE_VALUE eValue)
4283 {
4284 MS_U8 u8Type;
4285
4286 u8Type=(MS_U8)eType;
4287
4288 MS_BOOL retTx1, retTx2;
4289 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4290 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4291 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4292 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4293 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4294
4295
4296 if (retTx1 == FALSE || retTx2 == FALSE)
4297 {
4298 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
4299 return;
4300 }
4301
4302 switch(u8Type)
4303 {
4304 case SPDIF_CHANNEL_STATUS_FS:
4305 stDigitalChannelStatusTx1.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx1
4306 stDigitalChannelStatusTx2.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx2
4307 break;
4308 case SPDIF_CHANNEL_STATUS_CATEGORY:
4309 stDigitalChannelStatusTx1.u8Category = (MS_U8)eValue; // Tx1 By-pass L- bit
4310 stDigitalChannelStatusTx2.u8Category = (MS_U8)eValue; // Tx2 By-pass L- bit
4311 break;
4312 case SPDIF_CHANNEL_STATUS_PCM_FORMAT:
4313 stDigitalChannelStatusTx1.u8PcmFormatControl = (MS_U8)eValue; // Tx1 By-pass Copy right bit
4314 stDigitalChannelStatusTx2.u8PcmFormatControl = (MS_U8)eValue; // Tx2 By-pass Copy right bit
4315 break;
4316
4317 default :
4318 break;
4319 }
4320
4321 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4322 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4323 }
4324
4325 ////////////////////////////////////////////////////////////////////////////////
4326 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_ChannelStatus_CTRL()
4327 /// @brief \b Function \b Description: This routine is used to control SPDIF CS in detail.
4328 /// @return MS_U8 \b :
4329 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode,AUDIO_SPDIF_CS_TYPE_STATUS status)4330 MS_BOOL HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode, AUDIO_SPDIF_CS_TYPE_STATUS status)
4331 {
4332 MS_BOOL status_rtn = FALSE;
4333 MS_BOOL retTx1, retTx2;
4334
4335 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4336 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4337 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4338 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4339 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4340
4341 if (retTx1 == FALSE || retTx2 == FALSE)
4342 {
4343 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
4344 return status_rtn;
4345 }
4346
4347 switch (cs_mode)
4348 {
4349 case SPDIF_CS_CategoryCode:
4350 switch(status)
4351 {
4352 case SPDIF_CS_Category_BroadCast:
4353 stDigitalChannelStatusTx1.u8Category = 0x20;
4354 stDigitalChannelStatusTx2.u8Category = 0x20;
4355 break;
4356
4357 case SPDIF_CS_Category_General:
4358 stDigitalChannelStatusTx1.u8Category = 0x00;
4359 stDigitalChannelStatusTx2.u8Category = 0x00;
4360 break;
4361
4362 case SPDIF_CS_Category_BroadCast_JP:
4363 stDigitalChannelStatusTx1.u8Category = 0x20;
4364 stDigitalChannelStatusTx2.u8Category = 0x20;
4365 break;
4366
4367 case SPDIF_CS_Category_BroadCast_EU:
4368 stDigitalChannelStatusTx1.u8Category = 0x30;
4369 stDigitalChannelStatusTx2.u8Category = 0x30;
4370 break;
4371
4372 case SPDIF_CS_Category_BroadCast_USA:
4373 stDigitalChannelStatusTx1.u8Category = 0x26;
4374 stDigitalChannelStatusTx2.u8Category = 0x26;
4375 break;
4376
4377 default :
4378 stDigitalChannelStatusTx1.u8Category = 0x00;
4379 stDigitalChannelStatusTx2.u8Category = 0x00;
4380 break;
4381 }
4382 status_rtn = TRUE;
4383 break;
4384
4385 case SPDIF_CS_CopyRight:
4386 if(status == SPDIF_CS_CopyRight_CP)
4387 {
4388 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4389 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4390 }
4391 if(status == SPDIF_CS_CopyRight_NonCP)
4392 {
4393 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4394 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4395 }
4396 status_rtn = TRUE;
4397 break;
4398
4399 case SPDIF_CS_SourceNumber:
4400 if(status == SPDIF_CS_SourceNumber_2)
4401 {
4402 stDigitalChannelStatusTx1.u8SourceNumber = 0x40;
4403 stDigitalChannelStatusTx2.u8SourceNumber = 0x40;
4404 }
4405 if(status == SPDIF_CS_SourceNumber_5)
4406 {
4407 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4408 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4409 }
4410 if(status == SPDIF_CS_SourceNumber_6)
4411 {
4412 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4413 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4414 }
4415 status_rtn = TRUE;
4416 break;
4417
4418 case SPDIF_CS_ChannelNumber:
4419 if(status == SPDIF_CS_ChannelNumber_A_Left)
4420 {
4421 stDigitalChannelStatusTx1.u8ChannelNumber = 0x08;
4422 stDigitalChannelStatusTx2.u8ChannelNumber = 0x08;
4423 }
4424 if(status == SPDIF_CS_ChannelNumber_B_Right)
4425 {
4426 stDigitalChannelStatusTx1.u8ChannelNumber = 0x04;
4427 stDigitalChannelStatusTx2.u8ChannelNumber = 0x04;
4428 }
4429 if(status == SPDIF_CS_ChannelNumber_C)
4430 {
4431 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0C;
4432 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0C;
4433 }
4434 if(status == SPDIF_CS_ChannelNumber_D)
4435 {
4436 stDigitalChannelStatusTx1.u8ChannelNumber = 0x02;
4437 stDigitalChannelStatusTx2.u8ChannelNumber = 0x02;
4438 }
4439 if(status == SPDIF_CS_ChannelNumber_E)
4440 {
4441 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0A;
4442 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0A;
4443 }
4444 if(status == SPDIF_CS_ChannelNumber_F)
4445 {
4446 stDigitalChannelStatusTx1.u8ChannelNumber = 0x06;
4447 stDigitalChannelStatusTx2.u8ChannelNumber = 0x06;
4448 }
4449 status_rtn = TRUE;
4450 break;
4451
4452 case SPDIF_CS_SmpFreq:
4453 switch (status)
4454 {
4455 case SPDIF_CS_SmpFreq_192:
4456 stDigitalChannelStatusTx1.u8SamplingRate = 0x70;
4457 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
4458 break;
4459
4460 case SPDIF_CS_SmpFreq_96:
4461 stDigitalChannelStatusTx1.u8SamplingRate = 0x50;
4462 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
4463 break;
4464
4465 case SPDIF_CS_SmpFreq_48:
4466 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
4467 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
4468 break;
4469
4470 case SPDIF_CS_SmpFreq_176:
4471 stDigitalChannelStatusTx1.u8SamplingRate = 0x30;
4472 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
4473 break;
4474
4475 case SPDIF_CS_SmpFreq_88:
4476 stDigitalChannelStatusTx1.u8SamplingRate = 0x10;
4477 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
4478 break;
4479
4480 case SPDIF_CS_SmpFreq_44:
4481 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4482 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4483 break;
4484
4485 case SPDIF_CS_SmpFreq_64:
4486 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4487 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4488 break;
4489
4490 case SPDIF_CS_SmpFreq_32:
4491 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
4492 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
4493 break;
4494
4495 default:
4496 status_rtn = FALSE;
4497 break;
4498 }
4499 status_rtn = TRUE;
4500 break;
4501
4502 case SPDIF_CS_ClockAcc:
4503 status_rtn = TRUE;
4504 break;
4505
4506 case SPDIF_ChannelAB:
4507 if (status == SPDIF_ChannelAB_Invalid_ON)
4508 {
4509 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx1 Invalid bit=high in non-PCM mode
4510 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx2 Invalid bit=high in non-PCM mode
4511 }
4512 if (status == SPDIF_ChannelAB_Invalid_OFF)
4513 {
4514 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx1 Invalid bit=low in PCM mode
4515 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx2 Invalid bit=low in PCM mode
4516 }
4517 status_rtn = TRUE;
4518 break;
4519
4520 case SPDIF_CS_CopyProtect:
4521 switch (status)
4522 {
4523 case SPDIF_CS_CopyProtect_CopyFree:
4524 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4525 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4526 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4527 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4528 status_rtn = TRUE;
4529 break;
4530
4531 case SPDIF_CS_CopyProtect_CopyOnce:
4532 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4533 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4534 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4535 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4536 status_rtn = TRUE;
4537 break;
4538
4539 case SPDIF_CS_CopyProtect_CopyNever:
4540 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4541 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
4542 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4543 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
4544 status_rtn = TRUE;
4545 break;
4546
4547 default:
4548 status_rtn = FALSE;
4549 break;
4550 }
4551 break;
4552
4553 default:
4554 status_rtn = FALSE;
4555 break;
4556
4557 }
4558
4559 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4560 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4561
4562 return(status_rtn);
4563 }
4564
4565 ////////////////////////////////////////////////////////////////////////////////
4566 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_Monitor_SamplingRate()
4567 /// @brief \b Function \b Description: This routine is to set ADC clock for SPDIF raw out
4568 /// @param <IN> \b NONE :
4569 /// @param <OUT> \b NONE :
4570 /// @param <RET> \b NONE :
4571 /// @param <GLOBAL> \b NONE :
4572 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)4573 void HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)
4574 {
4575 HAL_AUDIO_Set_DecimationMode(AUDIO_HDMI_OUTPUT, (g_AudioVars2->g_HDMINonPcmPath));
4576 return;
4577 }
4578
4579 ////////////////////////////////////////////////////////////////////////////////
4580 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetOutputType()
4581 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4582 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource,AUDIO_SPDIF_OUTPUT_TYPE eType)4583 void HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource, AUDIO_SPDIF_OUTPUT_TYPE eType)
4584 {
4585 eSource=eSource;
4586 eType=eType;
4587 }
4588
4589 ///-----------------------------------------------------------------------------
4590 ////////////////////////////////////////////////////////////////////////////////
4591 ////////////////////////////////////////////////////////////////////////////////
4592 ///
4593 /// AUDIO HDMI Relational Hal Function
4594 ///
4595 ////////////////////////////////////////////////////////////////////////////////
4596 ////////////////////////////////////////////////////////////////////////////////
4597 ///-----------------------------------------------------------------------------
4598 ////////////////////////////////////////////////////////////////////////////////
4599 /// @brief \b Function \b Name: _HAL_AUDIO_HDMI_Tx_SetMute()
4600 /// @brief \b Function \b Description: This routine is used to mute HDMI Tx output(by DSP)
4601 /// @param <IN> \b bEnMute : 0--Disable mute
4602 /// 1--Enable mute
4603 /// @param <OUT> \b NONE :
4604 /// @param <RET> \b NONE :
4605 /// @param <GLOBAL> \b NONE :
4606 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)4607 void _HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)
4608 {
4609 if(bEnMute == 1)
4610 {
4611 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x80, 0x80); // Software Mute
4612 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
4613 }
4614 else
4615 {
4616 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x80, 0x00); // Software unMute
4617 MsOS_DelayTask(30);
4618 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
4619 }
4620 }
4621
4622 ////////////////////////////////////////////////////////////////////////////////
4623 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor()
4624 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status
4625 /// @param <IN> \b NONE :
4626 /// @param <OUT> \b NONE :
4627 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4628 /// @param <GLOBAL> \b NONE :
4629 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor(void)4630 MS_BOOL HAL_AUDIO_HDMI_NonpcmMonitor(void)
4631 {
4632 MS_BOOL bHdmiNonPcmMode = FALSE;
4633 MS_U8 u8TargetPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
4634 MS_U8 u8CurrentPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
4635
4636 HAL_AUDIO_AbsWriteMaskByte(0x1027C8, 0x02, 0x02); // Add audio bank offset
4637 if (((HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_INPUT) & 0xC0) == 0x40) || (HAL_AUDIO_HDMI_NonpcmMonitor2() == 0x1))
4638 {
4639 u8TargetPcmRenderControl = 0; //decoder mode
4640 bHdmiNonPcmMode = TRUE;
4641 }
4642 else
4643 {
4644 u8TargetPcmRenderControl = 2; //stereo mode
4645 bHdmiNonPcmMode = FALSE;
4646 }
4647
4648 /* if current main input source is HDMI, then configure R2's PCM Render */
4649 if (g_AudioVars2->eAudioSource == E_AUDIO_INFO_HDMI_IN)
4650 {
4651 u8CurrentPcmRenderControl = (HAL_AUR2_ReadByte(REG_SNDR2_MBOX_BYTE_DAP_SEL) & 0x06) >> 1;
4652 if (u8TargetPcmRenderControl != u8CurrentPcmRenderControl)
4653 {
4654 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8TargetPcmRenderControl << 1));
4655 }
4656 }
4657
4658 return bHdmiNonPcmMode;
4659 }
4660
4661 ////////////////////////////////////////////////////////////////////////////////
4662 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor2()
4663 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status from DSP
4664 /// @param <IN> \b NONE :
4665 /// @param <OUT> \b NONE :
4666 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4667 /// @param <GLOBAL> \b NONE :
4668 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor2(void)4669 MS_U8 HAL_AUDIO_HDMI_NonpcmMonitor2(void)
4670 {
4671 MS_U32 HDMI_lock_status_tmp;
4672 HDMI_lock_status_tmp = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_npcm_lock);
4673 if (HDMI_lock_status_tmp == 0x30)
4674 {
4675 return (1);
4676 }
4677 else
4678 {
4679 return (0);
4680 }
4681 }
4682
4683 ////////////////////////////////////////////////////////////////////////////////
4684 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_DolbyMonitor() @@Need_Modify
4685 /// @brief \b Function \b Description: Report HDMI non-PCM Dolby mod status
4686 /// @param <IN> \b NONE :
4687 /// @param <OUT> \b NONE :
4688 /// @param <RET> \b u8DolbyModeType :
4689 /// 0-- Other mode
4690 /// 1-- Dolby mode
4691 /// @param <GLOBAL> \b NONE :
4692 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_DolbyMonitor(void)4693 MS_U8 HAL_AUDIO_HDMI_DolbyMonitor(void)
4694 {
4695 return HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_HDMI_PC);
4696 }
4697
4698 ////////////////////////////////////////////////////////////////////////////////
4699 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_SetNonpcm() @@Need_Modify
4700 /// @brief \b Function \b Description: Set HDMI PCM/non-PCM Mode
4701 /// @param <IN> \b nonPCM_en :
4702 /// -- 0: PCM mode
4703 /// -- 1: non-PCM mode
4704 /// @param <OUT> \b NONE :
4705 /// @param <RET> \b NONE :
4706 /// @param <GLOBAL> \b NONE :
4707 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)4708 void HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)
4709 {
4710 //=======================================================
4711 Hdmi_Input_Path HDMI_INPUT_PATH ;
4712 MS_BOOL bIsNonPCM= FALSE;
4713 MS_U8 u8DecoderType = 0;
4714
4715 bIsNonPCM = (MS_BOOL)(nonPCM_en & HDMI_NonPCM_Mask); // Use bit 1 mask check PCM/nonPCM
4716 HDMI_INPUT_PATH = (Hdmi_Input_Path)(nonPCM_en & HDMI_Input_Path_Mask); // Use bit2 mask check main or sub in PIP
4717
4718 if (bIsNonPCM) //====== HDMI nonpcm mode =======
4719 {
4720 u8DecoderType = HAL_AUDIO_HDMI_DolbyMonitor();
4721
4722 switch(u8DecoderType)
4723 {
4724 case AU_HDMI_DTS_TYPE1:
4725 case AU_HDMI_DTS_TYPE2:
4726 case AU_HDMI_DTS_TYPE3:
4727 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4728 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_DTS);
4729 else
4730 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_DTS);
4731
4732 break;
4733 case AU_HDMI_AC3:
4734 case AU_HDMI_AC3P:
4735 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4736 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_AC3);
4737 else
4738 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_AC3);
4739
4740 break;
4741 };
4742
4743 // Audio Input path config
4744 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4745 {
4746 // HDMI in 2nd Decoder
4747 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4748 {
4749 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_6);
4750 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
4751 }
4752 else
4753 {
4754 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_MAIN);
4755 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
4756 }
4757 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP); // Stop
4758 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG,0x07,0x04);
4759 MsOS_DelayTask(10);
4760 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_PLAY); // PlaY
4761 }
4762 else // HDMI in 1st Decoder
4763 {
4764 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4765 {
4766 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_6);
4767 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
4768 }
4769 else
4770 {
4771 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_MAIN);
4772 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
4773 }
4774
4775 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP); // Stop
4776 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04);
4777 MsOS_DelayTask(10);
4778 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_PLAY); // Play
4779 }
4780
4781 //========= Set for S/PDIF out ===========
4782 HAL_AUDIO_SPDIF_SetMode(_HAL_AUDIO_SPDIF_GetMode(), E_AUDIO_INFO_HDMI_IN);
4783
4784 //Byte swap setting
4785 if (HAL_AUDIO_HDMI_DolbyMonitor() == AU_HDMI_AC3P)
4786 {
4787 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 1, 0);
4788 }
4789 else
4790 {
4791 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 0, 0);
4792 }
4793 }
4794 else //====== HDMI pcm mode =======
4795 {
4796 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4797 {
4798 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_6);
4799 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x19);
4800 }
4801 else
4802 {
4803 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_MAIN);
4804 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x19);
4805 }
4806
4807 HAL_AUDIO_SPDIF_SetMode(SPDIF_OUT_PCM, E_AUDIO_INFO_HDMI_IN);
4808 }
4809
4810 }
4811
4812 ////////////////////////////////////////////////////////////////////////////////
4813 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_AC3_PathCFG() @@Need_Modify
4814 /// @brief \b Function \b Description: Set DVB/HDMI AC3 path Control
4815 /// @param <IN> \b u8Ctrl :
4816 /// -- 0: DVB2_AD path
4817 /// -- 1: HDMI path
4818 /// @param <OUT> \b NONE :
4819 /// @param <RET> \b NONE :
4820 /// @param <GLOBAL> \b NONE :
4821 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)4822 void HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)
4823 {
4824 if (u8Ctrl == 1)
4825 { // HDMI
4826 /* use CH1 decode HDMI AC3 */
4827 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04); // HDMI_AC3 REG CFG
4828 }
4829 else
4830 { // DTV
4831 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x00); // DVB1 REG CFG
4832 }
4833 }
4834
4835
4836 ////////////////////////////////////////////////////////////////////////////////
4837 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Get_SYNTH_FREQ() @@Need_Modify
4838 /// @brief \b Function \b Description: Audio HDMI CTS-N synthesizer input signal detect.
4839 /// @param <IN> \b NONE :
4840 /// @param <OUT> \b MS_U16 : return freq. If no signal, return 0
4841 /// @param <RET> \b NONE :
4842 /// @param <GLOBAL> \b NONE :
4843 ////////////////////////////////////////////////////////////////////////////////
4844
HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)4845 MS_U16 HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)
4846 {
4847 MS_U16 freq;
4848
4849 freq = HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH) + 0x100 * HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH+1);
4850
4851 if(freq & 0x8000)
4852 return 0; //no signal
4853
4854 return freq;
4855 }
4856
4857 ////////////////////////////////////////////////////////////////////////////////
4858 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Set_DwonSample() @@Cathy
4859 /// @brief \b Function \b Description: set HDMI downsample rate
4860 /// @param <IN> \b MS_U8 : donwsample ratio ; no need in T3
4861 /// @param <OUT> \b NONE :
4862 /// @param <RET> \b NONE :
4863 /// @param <GLOBAL> \b NONE :
4864 ////////////////////////////////////////////////////////////////////////////////
4865
HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)4866 void HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)
4867 {
4868 ratio=ratio; // No need in T3
4869 }
4870
4871
4872 ////////////////////////////////////////////////////////////////////////////////
4873 /// @brief \b Function \b Name: HAL_AUDIO_HDMIAutoMute() @@Need_Modify
4874 /// @brief \b Function \b This routine sets the automute function of HDMI.
4875 /// @param <IN> \b MS_U8 : ch : 0~5
4876 /// value: register value
4877 /// @param <OUT> \b NONE :
4878 /// @param <RET> \b NONE :
4879 /// @param <GLOBAL> \b NONE :
4880 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMIAutoMute(MS_U8 ch,MS_U8 value)4881 void HAL_AUDIO_HDMIAutoMute(MS_U8 ch, MS_U8 value)
4882 {
4883 if(ch < 4)
4884 {
4885 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+(ch<<1),value);
4886 }
4887 else if(ch == 4)
4888 {
4889 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+1,value);
4890 }
4891 else if(ch == 5)
4892 {
4893 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL2+1,value);
4894 }
4895 }
4896
4897 ////////////////////////////////////////////////////////////////////////////////
4898 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Tx_GetStatus()
4899 /// @brief \b Function \b Description: This routine is used to get HDMI Tx status
4900 /// @param onOff \b : HDMI tx function is availible in this chip ?
4901 /// @param hdmi_SmpFreq \b : Audio current sample freq for tx
4902 /// @param outType \b : PCM mode or nonPCM mode
4903 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL * onOff,AUDIO_FS_TYPE * hdmi_SmpFreq,HDMI_TX_OUTPUT_TYPE * outType)4904 void HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL *onOff, AUDIO_FS_TYPE *hdmi_SmpFreq, HDMI_TX_OUTPUT_TYPE *outType )
4905 {
4906 *onOff = TRUE;
4907 *hdmi_SmpFreq = (AUDIO_FS_TYPE)(HAL_MAD_GetCommInfo(Audio_Comm_infoType_hdmiTx_outFreq));
4908 *outType = (HDMI_TX_OUTPUT_TYPE)(HAL_MAD_GetCommInfo(Audio_Comm_infoType_hdmiTx_outType));
4909 }
4910
4911
4912
4913 ///-----------------------------------------------------------------------------
4914 ////////////////////////////////////////////////////////////////////////////////
4915 ////////////////////////////////////////////////////////////////////////////////
4916 ///
4917 /// AUDIO Internel Use Hal Function
4918 ///
4919 ////////////////////////////////////////////////////////////////////////////////
4920 ////////////////////////////////////////////////////////////////////////////////
4921 ///-----------------------------------------------------------------------------
4922
4923 ////////////////////////////////////////////////////////////////////////////////
4924 /// @brief \b Function \b Name: _HAL_AUDIO_InitStep1() @@Need_Modify
4925 /// @brief \b Function \b Description: This routine is the initialization for Audio module(Step1).
4926 /// @param <IN> \b NONE :
4927 /// @param <OUT> \b NONE :
4928 /// @param <RET> \b NONE :
4929 /// @param <GLOBAL> \b NONE :
4930 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_InitStep1(void)4931 void _HAL_AUDIO_InitStep1(void)
4932 {
4933 HAL_AUDIO_WriteInitTable();
4934 HAL_AUDIO_SetPowerOn(1);
4935 HAL_SIF_TriggerSifPLL();
4936
4937 HAL_AUDIO_SwResetMAD();
4938
4939 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0082);
4940 AUDIO_DELAY1MS(2);
4941 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0083);
4942 // Reset Audio MIU Request for DEC-DSP
4943 HAL_MAD_DisEn_MIUREQ();
4944
4945 }
4946
4947
4948 ////////////////////////////////////////////////////////////////////////////////
4949 /// @brief \b Function \b Name: HAL_AUDIO_SetDspBaseAddr()
4950 /// @brief \b Function \b Description: This function is used to set bin file base address in flash for Audio module.
4951 /// @param <IN> \b u8Index :
4952 /// @param <IN> \b Bin_Base_Address :
4953 /// @param <IN> \b Mad_Base_Buffer_Adr :
4954 /// @param <OUT> \b NONE :
4955 /// @param <RET> \b NONE :
4956 /// @param <GLOBAL> \b NONE :
4957 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index,MS_PHY phyBin_Base_Address,MS_PHY phyMad_Base_Buffer_Adr)4958 void HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index, MS_PHY phyBin_Base_Address, MS_PHY phyMad_Base_Buffer_Adr)
4959 {
4960 HALAUDIO_CHECK_SHM_INIT;
4961
4962 g_AudioVars2->g_DSPMadMIUBank[u8Index] = (MS_U8) (phyMad_Base_Buffer_Adr & 0x0000000F);
4963 phyMad_Base_Buffer_Adr &= 0xFFFFFFF0;
4964 switch(u8Index)
4965 {
4966 case(DSP_ADV): //DSP_ADV=R2=2
4967 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = phyBin_Base_Address; //R2 ADDR setting
4968 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = phyMad_Base_Buffer_Adr;
4969 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
4970 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
4971 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
4972
4973 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = phyBin_Base_Address; //SE ADEC ADDR setting
4974 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = phyMad_Base_Buffer_Adr + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
4975 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
4976 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
4977 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
4978
4979 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = phyBin_Base_Address; //Comm ADDR setting
4980 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
4981 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
4982 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
4983 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
4984 break;
4985 default:
4986 u8Index = u8Index;
4987 break;
4988 }
4989
4990 #ifndef MSOS_TYPE_NUTTX
4991 AUDIO_TEE_INFO_SHM_CHECK_NULL;
4992 REE_TO_TEE_MBX_MSG_SET_PARAM(0, u8Index);
4993 REE_TO_TEE_MBX_MSG_SET_PARAM(1, (MS_U8)(phyBin_Base_Address&0xFF));
4994 REE_TO_TEE_MBX_MSG_SET_PARAM(2, (MS_U8)((phyBin_Base_Address>>8)&0xFF));
4995 REE_TO_TEE_MBX_MSG_SET_PARAM(3, (MS_U8)((phyBin_Base_Address>>16)&0xFF));
4996 REE_TO_TEE_MBX_MSG_SET_PARAM(4, (MS_U8)((phyBin_Base_Address>>24)&0xFF));
4997 REE_TO_TEE_MBX_MSG_SET_PARAM(5, (MS_U8)(phyMad_Base_Buffer_Adr&0xFF));
4998 REE_TO_TEE_MBX_MSG_SET_PARAM(6, (MS_U8)((phyMad_Base_Buffer_Adr>>8)&0xFF));
4999 REE_TO_TEE_MBX_MSG_SET_PARAM(7, (MS_U8)((phyMad_Base_Buffer_Adr>>16)&0xFF));
5000 REE_TO_TEE_MBX_MSG_SET_PARAM(8, (MS_U8)((phyMad_Base_Buffer_Adr>>24)&0xFF));
5001 REE_TO_TEE_MBX_MSG_SET_PARAM_COUNT(9);
5002 HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr | REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
5003 #endif
5004 HALAUDIO_PRINT ("%d DSPBinBaseAddress = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPBinBaseAddress[u8Index]);
5005 HALAUDIO_PRINT ("%d DSPMadBaseBufferAdr = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index]);
5006 HALAUDIO_PRINT ("%d DSPMadMIUBank = %d\n", u8Index, g_AudioVars2->g_DSPMadMIUBank[u8Index]);
5007 }
5008
5009 ////////////////////////////////////////////////////////////////////////////////
5010 /// @brief \b Function \b Name: HAL_AUDIO_GetDspMadBaseAddr()
5011 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5012 /// @param <IN> \b u8Index :
5013 /// @param <OUT> \b NONE :
5014 /// @param <RET> \b MS_U32: return the MAD base address
5015 /// @param <GLOBAL> \b NONE :
5016 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)5017 MS_PHY HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)
5018 {
5019 HALAUDIO_CHECK_SHM_INIT;
5020
5021 if (u8Index == DSP_DEC) // MM case
5022 {
5023 return g_AudioVars2->g_DSPMadBaseBufferAdr[DSP_SE];
5024 }
5025 return g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5026 }
5027
5028 ////////////////////////////////////////////////////////////////////////////////
5029 /// @brief \b Function \b Name: HAL_AUDIO_GetDspBinBaseAddr()
5030 /// @brief \b Function \b Description: This function is used to get the Bin file base address.
5031 /// @param <IN> \b u8Index :
5032 /// @param <OUT> \b NONE :
5033 /// @param <RET> \b MS_U32: return the Bin file base address
5034 /// @param <GLOBAL> \b NONE :
5035 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)5036 MS_PHY HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)
5037 {
5038 HALAUDIO_CHECK_SHM_INIT;
5039
5040 return g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5041 }
5042
5043 ////////////////////////////////////////////////////////////////////////////////
5044 /// @brief \b Function \b Name: HAL_AUDIO_SetDspCodeType()
5045 /// @brief \b Function \b Description: This function is used to set the DSP code type.
5046 /// @param <IN> \b NONE :
5047 /// @param <OUT> \b NONE :
5048 /// @param <RET> \b MS_U8: DSP code type.
5049 /// @param <GLOBAL> \b NONE :
5050 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5051 void HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5052 {
5053 HALAUDIO_CHECK_SHM_INIT;
5054
5055 if(bFlag == FALSE)
5056 {
5057 DBG_AUDIO_ERROR(printf(" [Audio] DSP1 Load code fail !!! SetDspCodeType Fail !!! \r\n"));
5058 return;
5059 }
5060
5061 g_AudioVars2->g_DspCodeType = dspCodeType;
5062 }
5063
5064 ////////////////////////////////////////////////////////////////////////////////
5065 /// @brief \b Function \b Name: HAL_AUDIO_GetDspCodeType()
5066 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5067 /// @param <IN> \b NONE :
5068 /// @param <OUT> \b NONE :
5069 /// @param <RET> \b MS_U8: DSP code type.
5070 /// @param <GLOBAL> \b NONE :
5071 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspCodeType(void)5072 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDspCodeType(void)
5073 {
5074 HALAUDIO_CHECK_SHM_INIT;
5075
5076 return g_AudioVars2->g_DspCodeType;
5077 }
5078
5079
5080 ////////////////////////////////////////////////////////////////////////////////
5081 /// @brief \b Function \b Name: HAL_AUDIO_SetDsp2CodeType() @@Cathy
5082 /// @brief \b Function \b Description: This function is used to set the DSP2 code type.
5083 /// @param <IN> \b NONE :
5084 /// @param <OUT> \b NONE :
5085 /// @param <RET> \b MS_U8: DSP code type.
5086 /// @param <GLOBAL> \b NONE :
5087 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5088 void HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5089 {
5090 HALAUDIO_CHECK_SHM_INIT;
5091
5092 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5093 {
5094 return;
5095 }
5096
5097 if(bFlag == FALSE)
5098 {
5099 DBG_AUDIO_ERROR(printf(" [Audio] DSP2 Load code fail !!! SetDsp2CodeType Fail !!! \r\n"));
5100 return;
5101 }
5102
5103 g_AudioVars2->g_Dsp2CodeType = dspCodeType;
5104 }
5105
5106 ////////////////////////////////////////////////////////////////////////////////
5107 /// @brief \b Function \b Name: HAL_AUDIO_GetDsp2CodeType() @@Cathy
5108 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5109 /// @param <IN> \b NONE :
5110 /// @param <OUT> \b NONE :
5111 /// @param <RET> \b MS_U8: DSP code type.
5112 /// @param <GLOBAL> \b NONE :
5113 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDsp2CodeType(void)5114 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDsp2CodeType(void)
5115 {
5116 HALAUDIO_CHECK_SHM_INIT;
5117
5118 return g_AudioVars2->g_Dsp2CodeType;
5119 }
5120
5121 ////////////////////////////////////////////////////////////////////////////////
5122 /// @brief \b Function \b Name: HAL_AUDIO_GetDSPalive()
5123 /// @brief \b Function \b Description: This function is used to check if DSP alive.
5124 /// @param <IN> \b NONE :
5125 /// @param <OUT> \b NONE :
5126 /// @param <RET> \b MS_U8: DSP alive status.
5127 /// @param <GLOBAL> \b NONE :
5128 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDSPalive(void)5129 MS_U8 HAL_AUDIO_GetDSPalive(void)
5130 {
5131 HALAUDIO_CHECK_SHM_INIT;
5132
5133 return g_AudioVars2->g_u8DspAliveFlag;
5134 }
5135
5136 ////////////////////////////////////////////////////////////////////////////////
5137 /// @brief \b Function \b Name: HAL_AUDIO_SetDSPalive()
5138 /// @brief \b Function \b Description: This function is used to set flag after DSP alive.
5139 /// @param <IN> \b NONE :
5140 /// @param <OUT> \b NONE :
5141 /// @param <RET> \b NONE :
5142 /// @param <GLOBAL> \b NONE :
5143 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDSPalive(MS_U8 alive)5144 void HAL_AUDIO_SetDSPalive(MS_U8 alive)
5145 {
5146 HALAUDIO_CHECK_SHM_INIT;
5147
5148 g_AudioVars2->g_u8DspAliveFlag = alive;
5149 }
5150 ////////////////////////////////////////////////////////////////////////////////
5151 /// @brief \b Function \b Name: HAL_AUDIO_SetAdvSndEffDspCodeType() @@Cathy
5152 /// @brief \b Function \b Description: This function is used to set the DSP AdvSndEff code type.
5153 /// @param <IN> \b NONE :
5154 /// @param <OUT> \b NONE :
5155 /// @param <RET> \b MS_U8: DSP code type.
5156 /// @param <GLOBAL> \b NONE :
5157 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5158 void HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5159 {
5160 HALAUDIO_CHECK_SHM_INIT;
5161
5162 if(bFlag == FALSE)
5163 {
5164 DBG_AUDIO_ERROR(printf(" [Audio] ADV_DSP Load code fail !!! SetAdvSndEffDspCodeType Fail !!! \r\n"));
5165 return;
5166 }
5167
5168 g_AudioVars2->g_AdvSndEffDspCodeType = dspCodeType;
5169 }
5170
5171 ////////////////////////////////////////////////////////////////////////////////
5172 /// @brief \b Function \b Name: HAL_AUDIO_GetAdvSndEffDspCodeType() @@Cathy
5173 /// @brief \b Function \b Description: This function is used to get the DSP AdvSndEff code type.
5174 /// @param <IN> \b NONE :
5175 /// @param <OUT> \b NONE :
5176 /// @param <RET> \b MS_U8: DSP code type.
5177 /// @param <GLOBAL> \b NONE :
5178 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetAdvSndEffDspCodeType(void)5179 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetAdvSndEffDspCodeType(void)
5180 {
5181 HALAUDIO_CHECK_SHM_INIT;
5182
5183 return g_AudioVars2->g_AdvSndEffDspCodeType;
5184 }
5185
5186 ////////////////////////////////////////////////////////////////////////////////
5187 /// @brief \b Function \b Name: HAL_AUDIO_BackupMailbox() @@Need_Modify
5188 /// @brief \b Function \b Description: This function is used to backup SIF mailbox.
5189 /// @param <IN> \b NONE :
5190 /// @param <OUT> \b NONE :
5191 /// @param <RET> \b NONE :
5192 /// @param <GLOBAL> \b NONE :
5193 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BackupMailbox(void)5194 void HAL_AUDIO_BackupMailbox(void)
5195 {
5196 int i;
5197
5198 for(i=0;i<12;i++)
5199 {
5200 SIF_MailBoxArray[i]=HAL_AUDIO_ReadByte(REG_SE_M2D_MAIL_BOX_BASE+i);
5201 }
5202
5203 MAD2DecCMD = HAL_MAD2_GetDecCmd();
5204 MADDec1CMD = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
5205 MADDec2CMD = HAL_MAD_GetDecCmd(DVB_Audio_Decoder2);
5206 MADDec1Type = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask;
5207 MADDec2Type = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_TYPE) & adec_type_regmask;
5208
5209 HAL_MAD2_SetDecCmd(0x100); // CathyNeedRefine
5210 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
5211 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP);
5212
5213 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE1_TYPE, (MS_U8)adec_type_regmask, (MS_U8)adec_type_dummy);
5214 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE2_TYPE, (MS_U8)adec_type_regmask, (MS_U8)adec_type_dummy);
5215 }
5216
5217 ////////////////////////////////////////////////////////////////////////////////
5218 /// @brief \b Function \b Name: HAL_AUDIO_RestoreMailbox() @@Need_Modify
5219 /// @brief \b Function \b Description: This function is used to restore SIF mailbox.
5220 /// @param <IN> \b NONE :
5221 /// @param <OUT> \b NONE :
5222 /// @param <RET> \b NONE :
5223 /// @param <GLOBAL> \b NONE :
5224 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RestoreMailbox(void)5225 void HAL_AUDIO_RestoreMailbox(void)
5226 {
5227 int i;
5228
5229 for(i=0;i<12;i++)
5230 {
5231 HAL_AUDIO_WriteByte((REG_SE_M2D_MAIL_BOX_BASE+i), SIF_MailBoxArray[i]);
5232 }
5233 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0xFF); // Toggle 2BCE to update N.F value
5234 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0x00);
5235
5236 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE1_TYPE, (MS_U8)adec_type_regmask, (MS_U8)MADDec1Type);
5237 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE2_TYPE, (MS_U8)adec_type_regmask, (MS_U8)MADDec2Type);
5238
5239 HAL_MAD_SetDecCmd(MADDec1CMD);
5240 HAL_MAD_SetDSP2DecCmd(MADDec2CMD);
5241 HAL_MAD2_SetDecCmd(((MS_U16)MAD2DecCMD)+0x100);
5242 }
5243
5244
5245 ////////////////////////////////////////////////////////////////////////////////
5246 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5247 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5248 /// @param <IN> \b eType : sampleRate of PCM
5249 /// @param <OUT> \b NONE :
5250 /// @param <RET> \b NONE :
5251 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)5252 void HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)
5253 {
5254 MS_U32 audio_pcm_dmaRdr_bufSz = HW_DMA_RDR1_BUF_SIZE; //must be multiple of HW_DMA_RDR1_BUF_UNIT*2 = 0x2000
5255 MS_PHY audio_pcm_dmaRdr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
5256 MS_U16 synthrate, divisor;
5257 MS_U8 tmp1, tmp2, tmp3, tmp4;
5258 MS_U32 i;
5259
5260 /* init DMA writer address */
5261 dma_writePtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5262 dma_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5263 dma_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base + audio_pcm_dmaRdr_bufSz);
5264
5265 /* New DMA Reader setting
5266 * Formula is :
5267 * Synthesizer Rate = 216MHz / Divisor(1, 2, 4 or 8) * 1024 / 256 / Sampling Rate(32Khz, 44.1KHz or 48KHz)
5268 */
5269 switch(sampleRate)
5270 {
5271 case SAMPLE_RATE_96000:
5272 divisor = 0;
5273 synthrate = 0x2328;
5274 break;
5275 case SAMPLE_RATE_44100:
5276 divisor = 0;
5277 synthrate = 0x4C87;
5278 break;
5279 case SAMPLE_RATE_32000:
5280 divisor = 0;
5281 synthrate = 0x6978;
5282 break;
5283 case SAMPLE_RATE_48000:
5284 divisor = 0;
5285 synthrate = 0x4650;
5286 break;
5287 case SAMPLE_RATE_22050:
5288 divisor = 1;
5289 synthrate = 0x4C87;
5290 break;
5291 case SAMPLE_RATE_16000:
5292 divisor = 1;
5293 synthrate = 0x6978;
5294 break;
5295 case SAMPLE_RATE_24000:
5296 divisor = 1;
5297 synthrate = 0x4650;
5298 break;
5299 case SAMPLE_RATE_11025:
5300 divisor = 2;
5301 synthrate = 0x4C87;
5302 break;
5303 case SAMPLE_RATE_8000:
5304 divisor = 2;
5305 synthrate = 0x6978;
5306 break;
5307 case SAMPLE_RATE_12000:
5308 divisor = 2;
5309 synthrate = 0x4650;
5310 break;
5311 default:
5312 divisor = 0;
5313 synthrate = 0x4650;
5314 break;
5315 }
5316
5317 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
5318 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04); //SEL_CLK_DMA_READER
5319 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F ); //CH8 sel to DMA Rdr
5320
5321 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //reset dma reader
5322
5323 HAL_AUDIO_WriteMaskByte(0x2B8E, 0xFF, ((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE) & 0xFF)); //DMA Reader Base Addr[7:0]
5324 HAL_AUDIO_WriteMaskReg(0x2B84, 0xFFFF,(((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>8) & 0xFFFF)); //DMA Reader Base Addr[23:8]
5325 HAL_AUDIO_WriteMaskByte(0x2B8F, 0x0F, (((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>24) & 0x0F)); //DMA Reader Base Addr[27:24]
5326
5327 HAL_AUDIO_WriteMaskReg(0x2B86, 0xFFFF, audio_pcm_dmaRdr_bufSz/BYTES_IN_MIU_LINE); //setting : DMA Reader Size
5328 HAL_AUDIO_WriteMaskReg(0x2B88, 0xFFFF, audio_pcm_dmaRdr_bufSz - 12); //setting : DMA Reader Overrun Thr
5329 HAL_AUDIO_WriteMaskReg(0x2B8A, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
5330
5331 /* synthersizer setting update */ //DMA reader
5332 HAL_AUDIO_WriteMaskByte(0x2CA4, 0x20, 0x20); //enable DMA synthesizer
5333 HAL_AUDIO_WriteMaskReg(0x2CB0, 0x6000, (divisor << 13)); //Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH
5334 HAL_AUDIO_WriteMaskReg(0x2C20, 0xFFFF, synthrate); //DMA synthesizer N.F.
5335
5336 /* Reset and Start DMA Reader */
5337 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x6402);
5338 AUDIO_DELAY1MS(1);
5339 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x2402);
5340
5341 /* Clear DMA Reader buffer */
5342 for ( i = 0; i < (HW_DMA_RDR1_BUF_SIZE/4); i++ )
5343 {
5344 tmp1 = 0;
5345 tmp2 = 0;
5346 tmp3 = 0;
5347 tmp4 = 0;
5348
5349 *dma_writePtr++ = tmp1;
5350 *dma_writePtr++ = tmp2;
5351 *dma_writePtr++ = tmp3;
5352 *dma_writePtr++ = tmp4;
5353 }
5354
5355 /* Reset Write Pointer */
5356 dma_writePtr = dma_bufStartAddress;
5357 }
5358
5359 ////////////////////////////////////////////////////////////////////////////////
5360 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5361 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5362 /// @param <IN> \b eType : sampleRate of PCM
5363 /// @param <OUT> \b NONE :
5364 /// @param <RET> \b NONE :
5365 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_AllInput_Init(void)5366 void HAL_AUDIO_DmaReader_AllInput_Init(void)
5367 {
5368 HAL_AUDIO_DmaReader_Init(SAMPLE_RATE_48000);
5369 return;
5370 }
5371
5372 ////////////////////////////////////////////////////////////////////////////////
5373 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_WritePCM()
5374 /// @brief \b Function \b Description: This routine is used to write PCM data into DMA reader Buffer
5375 /// @param <IN> \b eType : buffer bytes
5376 /// @param <OUT> \b NONE : TRUE or FALSE
5377 /// @param <RET> \b NONE :
5378 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_WritePCM(void * buffer,MS_U32 bytes)5379 MS_BOOL HAL_AUDIO_DmaReader_WritePCM(void* buffer, MS_U32 bytes)
5380 {
5381 MS_U8 *bufptr = (MS_U8 *)MS_PA2KSEG1((MS_VIRT)buffer);
5382 MS_U8 tmp1, tmp2, tmp3, tmp4, replay_flag=0;
5383 MS_U32 i, level_cnt;
5384
5385 // Mask LEVEL_CNT_MASK before read
5386 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5387 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5388 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5389
5390 if ( level_cnt <= 6 )
5391 {
5392 if ((HAL_AUDIO_ReadReg(0x2B80) & 0x0001) == 0x0001)
5393 replay_flag = 1;
5394
5395 /* reset dma reader */
5396 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //clear wr cntrs
5397
5398 /* Reset and Start DMA Reader */
5399 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x6402);
5400 AUDIO_DELAY1MS(1);
5401 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x2402);
5402
5403 /* Reset Write Pointer */
5404 dma_writePtr = dma_bufStartAddress;
5405
5406 printf("***** Audio DMAReader Buffer empty !! ***** \r\n");
5407 }
5408
5409 // Mask LEVEL_CNT_MASK before read
5410 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5411 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5412 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5413 if(level_cnt < (HW_DMA_RDR1_BUF_SIZE - bytes*2)/BYTES_IN_MIU_LINE)
5414 {
5415 for ( i = 0; i < (bytes/2); i++ )
5416 {
5417 tmp1 = 0;
5418 tmp2 = *bufptr++;
5419 tmp3 = *bufptr++;
5420 tmp4 = 0;
5421
5422 *dma_writePtr++ = tmp1;
5423 *dma_writePtr++ = tmp2;
5424 *dma_writePtr++ = tmp3;
5425 *dma_writePtr++ = tmp4;
5426
5427 if ( dma_writePtr >= dma_bufEndAddress )
5428 dma_writePtr = dma_bufStartAddress;
5429 }
5430 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, bytes*2/BYTES_IN_MIU_LINE);
5431 AUDIO_DELAY1US(5); // To prevent slow update of level_cnt
5432
5433 if (replay_flag == 1)
5434 {
5435 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
5436 AUDIO_DELAY1MS(1);
5437 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
5438 }
5439 return TRUE;
5440 }
5441 return FALSE;
5442 }
5443
5444 ////////////////////////////////////////////////////////////////////////////////
5445 /// @brief \b Function \b Name: HAL_AUDIO_SetEntertainmentMode()
5446 /// @brief \b Function \b Description: This routine is used to switch the DTV/KTV/GAME mode
5447 /// @param <IN> \b eMode :
5448 /// @param <RET> \b NONE :
5449 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)5450 void HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)
5451 {
5452 switch((int)eMode)
5453 {
5454 case AUDIO_ETMODE_DTV :
5455
5456 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x00);
5457 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5458 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x00); // ADC0 gain 0dB
5459 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5460
5461 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5462 break;
5463
5464 case AUDIO_ETMODE_KTV :
5465
5466 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5467 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x80); // enable KTV function
5468 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x80); // ADC0 gain 6dB
5469 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5470
5471 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_MIXED_LR, 0); // Switch SE-DSP sound mode to L+R for MIC0=L_CH, MIC1=R_CH
5472 break;
5473
5474 case AUDIO_ETMODE_KTV2 : // Use I2S input ; not MicroPhone in
5475
5476 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5477 HAL_AUDIO_WriteMaskByte(0x2D47 , 0xF0, 0xA0); // enable KTV mode; Skyworth (stone) model
5478 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5479 HAL_AUDIO_WriteMaskByte(0x2D5D , 0x80, 0x80); // Mute MIC volume (only mix MP3 & PCM DMA data)
5480 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5481
5482 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_MIXED_LR, 0); // Switch SE-DSP sound mode to L+R for MIC0=L_CH, MIC1=R_CH
5483 break;
5484
5485 case AUDIO_ETMODE_GAME :
5486
5487 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5488 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5489 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5490 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5491
5492 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5493 break;
5494
5495 case AUDIO_ETMODE_VOIP_ON:
5496 //Voip will setup snd system to GAME MODE,
5497 //In GAME MODE, Voip used 0x2D46[7:0] to
5498 //upload Raw_Delay_SE to DRAM.
5499 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0xA1);
5500
5501 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5502 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xE0);
5503 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0xC4);
5504
5505 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5506 AUDIO_DELAY1MS(1);
5507 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5508 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5509
5510 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_ON\r\n");
5511 break;
5512
5513 case AUDIO_ETMODE_VOIP_OFF:
5514 //disable upload Raw_Delay_SE to DRAM.
5515 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0x00);
5516
5517 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5518 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xD0);
5519 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0x20);
5520
5521 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5522 AUDIO_DELAY1MS(1);
5523 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5524 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5525
5526 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_OFF\r\n");
5527 break;
5528
5529 default :
5530 break;
5531 }
5532 }
5533
5534
5535 ////////////////////////////////////////////////////////////////////////////////
5536 /// @brief \b Function \b Name: HAL_AUDIO_SetSystem()
5537 /// @brief \b Function \b Description: This function will load
5538 /// different audio decoder to audio system.
5539 ///
5540 /// In Mstar audio system, we can support 1 or 2 decoders.
5541 /// One is for main DTV audio or Multimedia audio player.
5542 /// Another is for second audio decode (ex: used for Audio Description purpose)
5543 ///
5544 /// @param enDecSystem \b : (En_DVB_decSystemType) decoder type
5545 /// - parameter type "MSAPI_AUD_DVB_XXXX" is decoder type for main audio decoder
5546 /// - parameter type "MSAPI_AUD_DVB2_XXXX" is decoder type for second audio decoder
5547 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)5548 MS_BOOL HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)
5549 {
5550 //MS_BOOL pas2_sel = TRUE;
5551 MS_BOOL bRet = FALSE;
5552
5553 HAL_AUDIO_SetIsDtvFlag(TRUE);
5554 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, FALSE, 0);
5555
5556 // set decoder system
5557 switch (enDecSystem)
5558 {
5559 ////////////////////////////////////////////////
5560 // Audio Decoder 1
5561 ////////////////////////////////////////////////
5562 case MSAPI_AUD_DVB_MPEG:
5563 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5564 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5565 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
5566 break;
5567
5568 case MSAPI_AUD_DVB_AC3:
5569 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5570 AUDIO_DELAY1MS(1);
5571 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5572 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5573 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5574 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3, TRUE);
5575 break;
5576
5577 case MSAPI_AUD_DVB_AC3P:
5578 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5579 AUDIO_DELAY1MS(1);
5580 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5581 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5582 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5583 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
5584 break;
5585
5586 case MSAPI_AUD_DVB_MP3:
5587 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5588 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5589 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MP3, TRUE);
5590 break;
5591
5592 case MSAPI_AUD_DVB_AAC:
5593 case MSAPI_AUD_DVB_MS10_DDT:
5594 if (g_AudioVars2->DolbyAACFlag == 1)
5595 {
5596 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_aac);
5597 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5598 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
5599 }
5600 else
5601 {
5602 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_gaac);
5603 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5604 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
5605 }
5606 break;
5607
5608 case MSAPI_AUD_DVB_XPCM:
5609 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_xpcm);
5610 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5611 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
5612 break;
5613
5614 case MSAPI_AUD_DVB_RA8LBR:
5615 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ra8);
5616 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5617 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
5618 break;
5619
5620 case MSAPI_AUD_DVB_WMA:
5621 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5622 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5623 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
5624 break;
5625
5626 case MSAPI_AUD_DVB_DTS:
5627 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5628 AUDIO_DELAY1MS(1);
5629 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5630 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
5631 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5632 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5633 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
5634 break;
5635
5636 case MSAPI_AUD_DVB_DTSLBR:
5637 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5638 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5639 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTSLBR, TRUE);
5640 break;
5641
5642 case MSAPI_AUD_DVB_MS10_DDC:
5643 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5644 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5645 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDC, TRUE);
5646 break;
5647
5648 case MSAPI_AUD_DVB_WMA_PRO:
5649 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5650 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5651 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
5652 break;
5653
5654 case MSAPI_AUD_DVB_FLAC:
5655 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_flac);
5656 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5657 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
5658 break;
5659
5660 case MSAPI_AUD_DVB_VORBIS:
5661 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_vorbis);
5662 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5663 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
5664 break;
5665
5666 case MSAPI_AUD_DVB_AMR_NB:
5667 break;
5668
5669 case MSAPI_AUD_DVB_AMR_WB:
5670 break;
5671
5672 case MSAPI_AUD_DVB_DRA:
5673 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dra);
5674 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5675 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
5676 break;
5677
5678
5679 ////////////////////////////////////////////////
5680 // Audio Decoder 2
5681 ////////////////////////////////////////////////
5682 case MSAPI_AUD_DVB2_MPEG:
5683 case MSAPI_AUD_DVB2_MP3:
5684 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
5685 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5686 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MP3, TRUE);
5687 break;
5688
5689 case MSAPI_AUD_DVB2_AC3:
5690 case MSAPI_AUD_DVB2_AC3P:
5691 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
5692 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5693 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3, TRUE);
5694 break;
5695
5696 case MSAPI_AUD_DVB2_AAC:
5697 case MSAPI_AUD_DVB2_GAAC:
5698 if (g_AudioVars2->DolbyAACFlag == 1)
5699 {
5700 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_aac);
5701 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5702 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
5703 }
5704 else
5705 {
5706 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_gaac);
5707 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5708 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
5709 }
5710 break;
5711
5712 case MSAPI_AUD_DVB2_DTS:
5713 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dts);
5714 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5715 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
5716 break;
5717
5718 case MSAPI_AUD_DVB2_XPCM:
5719 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_xpcm);
5720 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5721 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
5722 break;
5723
5724 case MSAPI_AUD_ATVENC_FMTX:
5725 HAL_MAD2_ReLoadCode(AU_ATVENC_FMTx);
5726 break;
5727
5728 case MSAPI_AUD_ATVENC_BTSC:
5729 HAL_MAD2_ReLoadCode(AU_ATVENC_BTSC);
5730 break;
5731
5732 default:
5733 HAL_AUDIO_SetIsDtvFlag(FALSE);
5734 bRet = TRUE;
5735 break;
5736 }
5737
5738 return bRet;
5739 }
5740
5741 ////////////////////////////////////////////////////////////////////////////////
5742 /// @brief \b Function \b Name: HAL_AUDIO_GetDecSysSupportStatus()
5743 /// @brief \b Function \b Description: This function will report Audio Decoder support feature status when giving DecSystem type
5744 /// @param <IN> \b enDecSystem : Decoder type
5745 /// @param <RET> \b BOOL : True or False
5746 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)5747 MS_BOOL HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)
5748 {
5749 MS_BOOL SetDecSys_RtnStatus = FALSE;
5750 switch (enDecSystem)
5751 {
5752 ////////////////////////////////////////////////
5753 // Audio Decoder 1
5754 ////////////////////////////////////////////////
5755 case MSAPI_AUD_DVB_MPEG:
5756 case MSAPI_AUD_DVB_AC3:
5757 case MSAPI_AUD_DVB_AC3P:
5758 case MSAPI_AUD_DVB_MP3:
5759 case MSAPI_AUD_DVB_AAC:
5760 SetDecSys_RtnStatus = TRUE;
5761 break;
5762
5763 case MSAPI_AUD_DVB_MS10_DDT:
5764 case MSAPI_AUD_DVB_MS10_DDC:
5765 SetDecSys_RtnStatus = TRUE;
5766 break;
5767
5768 case MSAPI_AUD_DVB_XPCM:
5769 case MSAPI_AUD_DVB_RA8LBR:
5770 SetDecSys_RtnStatus = TRUE;
5771 break;
5772
5773 case MSAPI_AUD_DVB_WMA:
5774 case MSAPI_AUD_DVB_WMA_PRO:
5775 SetDecSys_RtnStatus = TRUE;
5776 break;
5777
5778 case MSAPI_AUD_DVB_DTS:
5779 SetDecSys_RtnStatus = TRUE;
5780 break;
5781
5782 case MSAPI_AUD_DVB_FLAC:
5783 SetDecSys_RtnStatus = TRUE;
5784 break;
5785
5786 case MSAPI_AUD_DVB_VORBIS:
5787 SetDecSys_RtnStatus = TRUE;
5788 break;
5789
5790 case MSAPI_AUD_DVB_AMR_NB:
5791 SetDecSys_RtnStatus = FALSE;
5792 break;
5793
5794 case MSAPI_AUD_DVB_AMR_WB:
5795 SetDecSys_RtnStatus = FALSE;
5796 break;
5797
5798 ////////////////////////////////////////////////
5799 // Audio Decoder 2
5800 ////////////////////////////////////////////////
5801 case MSAPI_AUD_DVB2_MPEG:
5802 case MSAPI_AUD_DVB2_MP3:
5803 SetDecSys_RtnStatus = TRUE;
5804 break;
5805
5806 case MSAPI_AUD_DVB2_AC3:
5807 case MSAPI_AUD_DVB2_AC3P:
5808 SetDecSys_RtnStatus = TRUE;
5809 break;
5810
5811 case MSAPI_AUD_DVB2_AAC:
5812 SetDecSys_RtnStatus = TRUE;
5813 break;
5814
5815 case MSAPI_AUD_DVB2_DDE:
5816 SetDecSys_RtnStatus = FALSE;
5817 break;
5818
5819 case MSAPI_AUD_DVB2_DTSE:
5820 SetDecSys_RtnStatus = FALSE;
5821 break;
5822
5823 case MSAPI_AUD_DVB2_XPCM:
5824 SetDecSys_RtnStatus = TRUE;
5825 break;
5826
5827 case MSAPI_AUD_DVB2_KTV:
5828 SetDecSys_RtnStatus = TRUE;
5829 break;
5830
5831 case MSAPI_AUD_DVB_TONE:
5832 case MSAPI_AUD_DVB_NONE:
5833 case MSAPI_AUD_DVB2_NONE:
5834 default:
5835 SetDecSys_RtnStatus = FALSE;
5836 break;
5837 }
5838 return(SetDecSys_RtnStatus);
5839 }
5840
5841 ////////////////////////////////////////////////////////////////////////////////
5842 /// @brief \b Function \b Name: HAL_AUDIO_AlgReloadCode()
5843 /// @brief \b Function \b Description: This routine is used to reload DSP code
5844 /// @param u8Type \b :
5845 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
5846 /// FALSE--DEC-DSP reload code fail
5847 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)5848 MS_BOOL HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
5849 {
5850 int time_out;
5851 MS_BOOL bRet = FALSE;
5852
5853 // Enter MCU/DSP hand-shake
5854 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5855 {
5856 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
5857 }
5858 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
5859 {
5860 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV2_END/0x100);
5861 }
5862 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
5863 {
5864 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
5865 }
5866 else
5867 {
5868 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
5869 }
5870
5871 // PIO[8] interrupt
5872 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
5873 HAL_MAD_TriggerPIO8();
5874
5875 //Wait Dsp Start reload Ack
5876 time_out = 0;
5877 while(time_out++<1000)
5878 {
5879 if(HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
5880 break;
5881 AUDIO_DELAY1MS(2);
5882 }
5883 if(time_out>=1000)
5884 {
5885 DBG_AUDIO_ERROR(" DSP Re-active1: %d\r\n",time_out);
5886 return FALSE;
5887 }
5888
5889 // Change to IDMA Port
5890 HAL_MAD_SetDspIDMA();
5891
5892 // Start to reload DSP code
5893 bRet = HAL_AUDSP_DspLoadCode(dspCodeType);
5894 if ( bRet == FALSE )
5895 {
5896 DBG_AUDIO_ERROR(" DSP reload fail !!\r\n");
5897 // PIO[8] interrupt
5898 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
5899 HAL_MAD_TriggerPIO8();
5900 HAL_MAD_SetMcuCmd(0x00); // In T3 T8, clear 0x2D9C after reload finish
5901 return FALSE;
5902 }
5903
5904 // Enter MCU/DSP hand-shake
5905 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5906 {
5907 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
5908 }
5909 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
5910 {
5911 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV2_END/0x100);
5912 }
5913 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
5914 {
5915 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
5916 }
5917 else
5918 {
5919 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
5920 }
5921
5922 // PIO[8] interrupt
5923 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
5924 HAL_MAD_TriggerPIO8();
5925
5926 // Wait Dsp End Reload Ack
5927 time_out = 0;
5928 while(time_out++<1500)
5929 {
5930 if(HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
5931 {
5932 break;
5933 }
5934 AUDIO_DELAY1MS(2);
5935 }
5936
5937 if(time_out>=1500)
5938 {
5939 DBG_AUDIO_ERROR(" DSP Re-active2: %d\r\n",time_out);
5940 return FALSE;
5941 }
5942
5943 HAL_MAD_SetMcuCmd(0x00); // In T3 T8, clear 0x2D9C after reload finish
5944
5945 return bRet;
5946 }
5947
5948 ////////////////////////////////////////////////////////////////////////////////
5949 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Check()
5950 /// @brief \b Function \b Description: Check if ALSA Interface is supported
5951 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
5952 /// @param <OUT> \b MS_BOOL : return TRUE if it's supported, else return FALSE
5953 /// @param <RET> \b NONE :
5954 /// @param <GLOBAL> \b NONE :
5955 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Check(void)5956 MS_BOOL HAL_AUDIO_ALSA_Check(void)
5957 {
5958 return TRUE;
5959 }
5960
5961 ////////////////////////////////////////////////////////////////////////////////
5962 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Enable()
5963 /// @brief \b Function \b Description: Enable/ Disable the path of ALSA
5964 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
5965 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
5966 /// @param <RET> \b NONE :
5967 /// @param <GLOBAL> \b NONE :
5968 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)5969 MS_BOOL HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)
5970 {
5971 if (bEnable == TRUE)
5972 {
5973 /* Set as GAME mode */
5974 HAL_AUDIO_SetInputPath(AUDIO_DSP3_DVB_INPUT , AUDIO_PATH_5);
5975 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5976 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5977 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5978 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5979
5980 return TRUE;
5981 }
5982 else
5983 {
5984 /* Do nothing for the moment */
5985 return FALSE;
5986 }
5987 }
5988
5989 ////////////////////////////////////////////////////////////////////////////////
5990 /// @brief \b Function \b Name: HAL_AUDIO_Alg2ReloadCode()
5991 /// @brief \b Function \b Description: This routine is used to reload the algorithm in se-dsp .
5992 /// @param u8Type \b : information of algorithm code
5993 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
5994 /// FALSE--DEC-DSP reload code fail
5995 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)5996 MS_BOOL HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
5997 {
5998 return TRUE;
5999 }
6000
6001 ////////////////////////////////////////////////////////////////////////////////
6002 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeDoneFlag() @@Cathy
6003 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
6004 /// @param <IN> \b NONE :
6005 /// @param <OUT> \b NONE :
6006 /// @param <RET> \b NONE :
6007 /// @param <GLOBAL> \b NONE :
6008 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeDoneTag(void)6009 MS_U16 HAL_AUDIO_GetUniDecodeDoneTag(void)
6010 {
6011 MS_U16 temp1, temp2, i;
6012
6013 for (i = 0; i < 100; i++)
6014 {
6015 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, AU_DEC_ID1 );
6016 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, AU_DEC_ID1 );
6017
6018 if (temp1 == temp2)
6019 {
6020 return (temp1);
6021 }
6022 }
6023
6024 return 0;
6025 }
6026
6027 ////////////////////////////////////////////////////////////////////////////////
6028 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeFrameCnt()
6029 /// @brief \b Function \b Description: This function is used to get the Decoder decoded frame count
6030 /// @param <IN> \b NONE:
6031 /// @param <OUT> \b NONE:
6032 /// @param <RET> \b NONE:
6033 /// @param <GLOBAL> \b NONE:
6034 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)6035 MS_U16 HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)
6036 {
6037 MS_U16 temp1, temp2, i;
6038
6039 for ( i = 0; i < 100; i++ )
6040 {
6041 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, eDSPId);
6042 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, eDSPId);
6043
6044 if ( temp1 == temp2 )
6045 {
6046 return (temp1);
6047 }
6048 }
6049
6050 return 0;
6051 }
6052
6053 //******************************************************************************
6054 // [Function Name]:
6055 // HAL_AUDIO_PTS_info
6056 // [Description]:
6057 // get PTS and OS time or set to reset these reference
6058 // [Arguments]:
6059 //
6060 //*******************************************************************************
HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info)6061 void HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info )
6062 {
6063 AUDIO_PTS_INFO PTS_info;
6064
6065 memcpy((void *)&PTS_info,(void *)access_PTS_info,sizeof(AUDIO_PTS_INFO));
6066
6067 // printf("HAL_AUDIO_PTS_info((0x%x, %d, %lld))\n",(unsigned int)access_PTS_info,(int)PTS_info.os_Time,PTS_info.curPTS);
6068 if(PTS_info.set2Clr) //setting value
6069 {
6070 curr_OS_Time = PTS_info.os_Time;
6071 curr_PTS = PTS_info.curPTS;
6072 }
6073 else // get PTS information
6074 {
6075
6076 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6077
6078 PTS_info.set2Clr = 0 ;
6079 PTS_info.os_Time = curr_OS_Time;
6080 PTS_info.curPTS = curr_PTS;
6081
6082 memcpy((void *)access_PTS_info,(void *)&PTS_info,sizeof(AUDIO_PTS_INFO));
6083
6084 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6085 }
6086 }
6087
HAL_AUDIO_DmaWriter_Init(void)6088 void HAL_AUDIO_DmaWriter_Init(void)
6089 {
6090 return;
6091 }
6092
6093 ////////////////////////////////////////////////////////////////////////////////
6094 /// @brief \b Function \b Name: HAL_AUDIO_RebootDecDSP()
6095 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RebootDecDSP(void)6096 void HAL_AUDIO_RebootDecDSP(void)
6097 {
6098 MS_U8 u8DspCodeType;
6099 AU_DVB_DECCMD deccmd_status;
6100 AUD_ERRMSG("\n*MAD Auto-Recovery DEC-R2* \n");
6101
6102 HALAUDIO_CHECK_SHM_INIT;
6103
6104 g_AudioVars2->g_u8AudioCrashFlag = TRUE;
6105
6106 u8DspCodeType=(MS_U8)(HAL_AUDIO_GetDspCodeType());
6107 deccmd_status = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
6108
6109 // Reset MAD module
6110 HAL_MAD_RSTMAD_DisEn_MIUREQ();
6111 AUDIO_DELAY1MS(2);
6112
6113 //if((u8DspCodeType & 0xF0) != 0x10 )
6114 {
6115 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, FALSE, 0); // Audio SIF channel enable setting -> disable
6116 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 0, 0);
6117
6118 AUDIO_DELAY1MS(2);
6119 }
6120 AUD_DBGMSG("*** Load code and reset DEC-R2 \n");
6121 HAL_MAD2_SetMemInfo();
6122 HAL_AUDIO_ResetDSP();
6123 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
6124 HAL_AUDSP_DECR2LoadCode();
6125 HAL_MAD_LoadCode((AUDIO_DSP_CODE_TYPE)u8DspCodeType);
6126
6127 HAL_MAD_SetDecCmd(deccmd_status);
6128 //if((u8DspCodeType & 0xF0) != 0x10 )
6129 {
6130 AUDIO_DELAY1MS(50);
6131 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 1, 0);
6132 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0); // Audio SIF channel enable setting -> enable
6133 }
6134 }
6135
6136 ////////////////////////////////////////////////////////////////////////////////
6137 /// @brief \b Function \b Name: HAL_AUDIO_DspReboot()
6138 /// @brief \b Function \b Description: This routine is used to do dsp reboot and some specific setting
6139 /// @param <IN> \b eType : param
6140 /// @param <RET> \b NONE :
6141 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspReboot(MS_U8 alive)6142 void HAL_AUDIO_DspReboot(MS_U8 alive)
6143 {
6144 alive = alive;
6145 }
6146
6147
6148 ////////////////////////////////////////////////////////////////////////////////
6149 /// @brief \b Function \b Name: HAL_AUDIO_ReadDspCounter()
6150 /// @brief \b Function \b Description: Read the DSP running counter
6151 /// @param CounterType \b :
6152 /// - DSP_DEC_MAIN_COUNTER ==> Decoder DSP Main loop counter
6153 /// - DSP_DEC_TIMER_COUNTER ==> Decoder Timer counter
6154 /// - DSP_SE_MAIN_COUNTER ==> SE DSP Main loop counter
6155 /// - DSP_SE_TIMER_COUNTER ==> SE Timer counter
6156 /// - DSP_SE_ISR_COUNTER ==> SE Interrupt ISR counter
6157 /// @return MS_U8 \b : Running counter value
6158 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)6159 MS_U8 HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)
6160 {
6161 MS_U8 u8CounterValue=0;
6162
6163 switch(CounterType)
6164 {
6165 case DSP_DEC_MAIN_COUNTER:
6166 break;
6167
6168 case DSP_DEC_TIMER_COUNTER:
6169 break;
6170
6171 case DSP_SE_MAIN_COUNTER:
6172 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_COUNTER);
6173 break;
6174
6175 case DSP_SE_TIMER_COUNTER:
6176 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_TIMER_COUNTER);
6177 break;
6178
6179 case DSP_SE_ISR_COUNTER:
6180 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_ISR_COUNTER);
6181 break;
6182
6183 case DEC_R2_MAIN_COUNTER:
6184 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_MAIN_COUNTER);
6185 break;
6186
6187 case DEC_R2_TIMER_COUNTER:
6188 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_TIMER_COUNTER);
6189 break;
6190
6191 case SND_R2_MAIN_COUNTER:
6192 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_MAIN_COUNTER);
6193 break;
6194
6195 case SND_R2_TIMER_COUNTER:
6196 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_TIMER_COUNTER);
6197 break;
6198
6199 default:
6200 break;
6201 }
6202 return u8CounterValue;
6203 }
6204
6205
6206 ////////////////////////////////////////////////////////////////////////////////
6207 /// @brief \b Function \b Name: HAL_AuProcessPowerDown_Wait()
6208 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
6209 /// @param bEnable \b : TRUE --Not wait,
6210 /// FALSE--wait
6211 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)6212 void HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)
6213 {
6214 bEnable = bEnable;
6215 }
6216
6217 ////////////////////////////////////////////////////////////////////////////////
6218 /// @brief \b Function \b Name: HAL_AUDIO_SendIntrupt()
6219 /// @brief \b Function \b Description: send a PIO8 interrupt to DSP
6220 /// @param bDspType \b :
6221 /// @param u8Cmd \b :
6222 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)6223 void HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)
6224 {
6225 if (bDspType == DSP_DEC)
6226 {
6227 HAL_MAD_SetPIOCmd(u8Cmd);
6228 HAL_MAD_TriggerPIO8();
6229 }
6230 else
6231 {
6232 HAL_MAD2_SetPIOCmd(u8Cmd);
6233 HAL_MAD2_TriggerPIO8();
6234 }
6235 }
6236
6237 ////////////////////////////////////////////////////////////////////////////////
6238 /// @brief \b Function \b Name: HAL_AUDIO_SeSystemLoadCode()
6239 /// @brief \b Function \b Description: This routine is used to load DSP code for SE-DSP .
6240 /// @return MS_BOOL \b : TRUE --DEC-DSP load code okay,
6241 /// FALSE--DEC-DSP load code fail
6242 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeSystemLoadCode(void)6243 MS_BOOL HAL_AUDIO_SeSystemLoadCode(void)
6244 {
6245 MS_U16 time_out = 0;
6246 //MS_U32 DEC_R2_ADDR = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV); // Get ADEC R2 Start address
6247 //MS_U32 SND_R2_ADDR = DEC_R2_ADDR + ADEC__R2_DDR_SIZE; // Get SND-R2 Start address
6248
6249 HAL_MAD2_SetDspIDMA();
6250
6251 AUD_DBGMSG("MDrv_AUDIO_SeSystemLoadCode() \r\n");
6252
6253 HAL_AUDSP_DspLoadCode(AU_SE_SYSTEM);
6254
6255 #if 0 //secure boot (Reserved)
6256 //Wait R2 boot code init finished Ack
6257 #ifndef CONFIG_MBOOT
6258 while(time_out++<100)
6259 {
6260 if((HAL_AUR2_ReadReg(REG_DECR2_BOOTCODE_DONE_ACK) == 0x1234)&&(HAL_AUR2_ReadReg(REG_SNDR2_BOOTCODE_DONE_ACK) == 0x1234))
6261 break;
6262 AUDIO_DELAY1MS(2);
6263 }
6264 #else
6265 while(time_out++<100)
6266 {
6267 if(HAL_AUR2_ReadReg(REG_DECR2_BOOTCODE_DONE_ACK) == 0x1234)
6268 break;
6269 AUDIO_DELAY1MS(2);
6270 }
6271 #endif
6272
6273 if(time_out>=100)
6274 {
6275 AUD_ERRMSG("audio R2 boot code timeout\n");
6276 }
6277 else
6278 {
6279 AUD_DBGMSG("audio R2 boot code success\n");
6280 }
6281
6282 HAL_SND_R2_EnableR2(FALSE); // stop SND-R2 after load R2 boot code
6283 HAL_DEC_R2_EnableR2(FALSE); // stop DEC-R2 after load R2 boot code
6284 HAL_AUR2_WriteMaskReg(REG_SDR_SWITCH_CTRL, 0x0002, 0x0002); //use SDR2 address [1]:0x1630 [0];0x1129
6285
6286 HAL_AUR2_WriteReg(REG_DECR2_ICMEM2_BASE_LO, (MS_U16)(DEC_R2_ADDR & 0xFFFF));
6287 HAL_AUR2_WriteReg(REG_DECR2_ICMEM2_BASE_HI, (MS_U16)((DEC_R2_ADDR >> 16) & 0xFFFF));
6288 HAL_AUR2_WriteReg(REG_DECR2_DCMEM_BASE_LO, (MS_U16)(DEC_R2_ADDR & 0xFFFF));
6289 HAL_AUR2_WriteReg(REG_DECR2_DCMEM_BASE_HI, (MS_U16)((DEC_R2_ADDR >> 16) & 0xFFFF));
6290 #ifndef CONFIG_MBOOT
6291 HAL_AUR2_WriteMaskReg(REG_SDR_SWITCH_CTRL, 0x0001, 0x0001); //use SDR2 address [1]:0x1630 [0];0x1129
6292 HAL_AUR2_WriteReg(REG_SNDR2_ICMEM2_BASE_LO, (MS_U16)(SND_R2_ADDR & 0xFFFF));
6293 HAL_AUR2_WriteReg(REG_SNDR2_ICMEM2_BASE_HI, (MS_U16)((SND_R2_ADDR >> 16) & 0xFFFF));
6294 HAL_AUR2_WriteReg(REG_SNDR2_DCMEM_BASE_LO, (MS_U16)(SND_R2_ADDR & 0xFFFF));
6295 HAL_AUR2_WriteReg(REG_SNDR2_DCMEM_BASE_HI, (MS_U16)((SND_R2_ADDR >> 16) & 0xFFFF));
6296 HAL_SND_R2_EnableR2(TRUE); // start SND-R2 after load R2 code
6297 #endif
6298 HAL_DEC_R2_init_SHM_param();
6299 HAL_DEC_R2_EnableR2(TRUE); // start DEC-R2 after load R2 code
6300 #endif
6301
6302 time_out = 0;
6303 //Wait Dsp/R2 init finished Ack
6304 #ifndef CONFIG_MBOOT
6305 while(time_out++<100)
6306 {
6307 if((HAL_AUR2_ReadByte(REG_DECR2_ACK1) == 0xE3)&&(HAL_AUR2_ReadByte(REG_SNDR2_ACK1) == 0xE3))
6308 break;
6309 AUDIO_DELAY1MS(2);
6310 }
6311 #else
6312 while(time_out++<100)
6313 {
6314 if(HAL_AUR2_ReadByte(REG_DECR2_ACK1) == 0xE3)
6315 break;
6316 AUDIO_DELAY1MS(2);
6317 }
6318 #endif
6319
6320 if(time_out>=100)
6321 {
6322 AUD_ERRMSG("DSP2 or R2 Re-Active\n");
6323 }
6324 else
6325 {
6326 AUD_DBGMSG("audio DSP_SE LoadCode success..\n");
6327 }
6328
6329 //inform DSP to start to run
6330 HAL_MAD2_SetMcuCmd(0xF3);
6331
6332 return TRUE;
6333 }
6334
6335 ////////////////////////////////////////////////////////////////////////////////
6336 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6337 ////////////////////////////////////////////////////////////////////////////////
6338 ////////////////////////////////////////////////////////////////////////////////
6339 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6340 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecoderLoadCode(void)6341 MS_BOOL HAL_AUDIO_DecoderLoadCode(void)
6342 {
6343 return TRUE;
6344 }
6345
6346 ////////////////////////////////////////////////////////////////////////////////
6347 /// @brief \b Function \b Name: HAL_AUDIO_init()
6348 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Init(MS_BOOL Initype)6349 MS_BOOL HAL_AUDIO_Init(MS_BOOL Initype)
6350 {
6351 Initype = Initype;
6352 return Initype;
6353 }
6354
6355 ////////////////////////////////////////////////////////////////////////////////
6356 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_TX_SetMode()
6357 /// @brief \b Function \b Description: This routine is used to set HDMI output mode
6358 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType,AUDIO_SOURCE_INFO_TYPE eSource)6359 void HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType, AUDIO_SOURCE_INFO_TYPE eSource)
6360 {
6361 HDMI_TX_OUTPUT_TYPE outType_tmp = outType;
6362 MS_U8 u8Dsp1CodeType = AU_DVB_STANDARD_INVALID;
6363 MS_U8 u8Dsp2CodeType = AU_DVB_STANDARD_INVALID;
6364 MS_U8 u8MainDspCodeType = AU_DVB_STANDARD_INVALID;
6365 MS_U8 u8NonPcmPath = ADEC1; /* R2: ADEC1, ADEC2 */
6366
6367 HALAUDIO_CHECK_SHM_INIT;
6368
6369 DBG_AUDIO(printf("=== HAL_AUDIO_HDMI_SetMode: %d, src:%d ===\n", outType, eSource));
6370
6371 if ( g_AudioVars2 != NULL )
6372 {
6373 u8Dsp1CodeType = g_AudioVars2->g_DspCodeType;
6374 u8Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
6375 }
6376 else
6377 {
6378 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: g_AudioVars2 should not be NULL !!\r\n", __FUNCTION__);
6379 return;
6380 }
6381
6382 switch (eSource)
6383 {
6384 case E_AUDIO_INFO_DTV_IN:
6385 {
6386 u8MainDspCodeType = u8Dsp1CodeType;
6387 u8NonPcmPath = ADEC1; /* R2 */
6388
6389 if((u8MainDspCodeType == AU_DVB_STANDARD_AAC)||(u8MainDspCodeType == AU_DVB_STANDARD_MS10_DDT))
6390 {
6391 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1)&0xFFFF) < 32000) // check if less than 32KHz
6392 outType_tmp = HDMI_OUT_PCM;
6393 }
6394 else if ((u8MainDspCodeType != AU_DVB_STANDARD_AC3) &&
6395 (u8MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
6396 (u8MainDspCodeType != AU_DVB_STANDARD_DTS) &&
6397 (u8MainDspCodeType != AU_DVB_STANDARD_DTSLBR))
6398 {
6399 outType_tmp = HDMI_OUT_PCM;
6400 }
6401
6402 break;
6403 }
6404
6405 case E_AUDIO_INFO_HDMI_IN:
6406 {
6407 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
6408 {
6409 u8NonPcmPath = ADEC2; /* R2 */
6410 u8MainDspCodeType = u8Dsp2CodeType;
6411 }
6412 else
6413 {
6414 u8NonPcmPath = ADEC1; /* R2 */
6415 u8MainDspCodeType = u8Dsp1CodeType;
6416 }
6417
6418 if((HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE) ||(outType==HDMI_OUT_PCM)) /* if Type is not Dolby type, bypass */
6419 {
6420 u8NonPcmPath = ADEC1; /* R2 */
6421 outType_tmp = HDMI_OUT_PCM;
6422 }
6423
6424 break;
6425 }
6426
6427 case E_AUDIO_INFO_MM_IN:
6428 case E_AUDIO_INFO_GAME_IN:
6429 {
6430 if(HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS)
6431 {
6432 u8MainDspCodeType = u8Dsp2CodeType;
6433 u8NonPcmPath = ADEC2; /* R2 */
6434 }
6435 else
6436 {
6437 u8MainDspCodeType = u8Dsp1CodeType;
6438 u8NonPcmPath = ADEC1; /* R2 */
6439 }
6440
6441 if((u8MainDspCodeType == AU_DVB_STANDARD_AAC)||(u8MainDspCodeType == AU_DVB_STANDARD_MS10_DDT))
6442 {
6443 if(u8NonPcmPath == ADEC1)
6444 {
6445 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1)&0xFFFF) < 32000) // check if less than 32KHz
6446 {
6447 outType_tmp = HDMI_OUT_PCM;
6448 u8NonPcmPath = ADEC1; /* R2 */
6449 }
6450 }
6451 else
6452 {
6453 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID3)&0xFFFF) < 32000) // check if less than 32KHz
6454 {
6455 outType_tmp = HDMI_OUT_PCM;
6456 u8NonPcmPath = ADEC1; /* R2 */
6457 }
6458 }
6459 }
6460 else
6461 {
6462 if (g_AudioVars2->g_hbr_bypass_enable == true)
6463 {
6464 if ((u8MainDspCodeType != AU_DVB_STANDARD_AC3) &&
6465 (u8MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
6466 (u8MainDspCodeType != AU_DVB_STANDARD_DTS) &&
6467 (u8MainDspCodeType != AU_DVB_STANDARD_DTSLBR) &&
6468 (u8MainDspCodeType != AU_DVB_STANDARD_DTSHD_ADO) &&
6469 (u8MainDspCodeType != AU_DVB_STANDARD_DolbyTrueHD_Bypass)&&
6470 (u8MainDspCodeType != AU_DEC_ES_BYPASS))
6471 {
6472 outType_tmp = HDMI_OUT_PCM;
6473 u8NonPcmPath = ADEC1; /* R2 */
6474 }
6475 }
6476 else
6477 {
6478 if ((u8MainDspCodeType != AU_DVB_STANDARD_AC3) &&
6479 (u8MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
6480 (u8MainDspCodeType != AU_DVB_STANDARD_DTS)&&
6481 (u8MainDspCodeType != AU_DVB_STANDARD_DTSLBR)&&
6482 (u8MainDspCodeType != AU_DEC_ES_BYPASS))
6483 {
6484 outType_tmp = HDMI_OUT_PCM;
6485 u8NonPcmPath = ADEC1; /* R2 */
6486 }
6487 }
6488 }
6489 break;
6490 }
6491
6492 default:
6493 {
6494 outType_tmp = HDMI_OUT_PCM;
6495 u8NonPcmPath = ADEC1; /*R2 */
6496 break;
6497 }
6498 }
6499
6500 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: outType_tmp %d, u8NonPcmPath %d\r\n", __FUNCTION__, outType_tmp, u8NonPcmPath);
6501
6502 switch (outType_tmp)
6503 {
6504 case HDMI_OUT_NONPCM:
6505 case HDMI_OUT_8CH_NONPCM:
6506 case HDMI_OUT_BYPASS:
6507 {
6508 /* Non-PCM */
6509 HAL_AUR2_WriteMaskByte(REG_R2_HDMI_NONPCM_PATH, 0x01, u8NonPcmPath);
6510 AUDIO_DELAY1MS(5);
6511 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, AU_DEC_ID1, 2, 0); /* Non-PCM */
6512 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, AU_DEC_ID3, 2, 0); /* Non-PCM */
6513 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select R2 */
6514 HAL_AUDIO_WriteMaskByte((REG_M2D_MAILBOX_SPDIF_CTRL+1), 0x20, 0x20); /* NONPCM Mode */
6515 HAL_AUDIO_WriteMaskByte(0x2C48, 0x80, 0x80); /* enable synthesizer */
6516 HAL_AUDIO_WriteMaskByte(0x2CB1, 0x04, 0x04); /* sel HDMI TX clock from synthesizer */
6517
6518 if (outType_tmp == HDMI_OUT_BYPASS)
6519 {
6520 AUDIO_DELAY1MS(10);
6521 /*
6522 * TODO
6523 * We should call HAL_MAD_SetAC3PInfo(),
6524 * but due to Audio_AC3P_infoType_hdmiTxBypass_enable case is not so good for the moment,
6525 * just configure settings directly here!
6526 */
6527 #if 0
6528 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, TRUE, ADEC1);
6529 #else
6530 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_DDP_HDMI_BYPASS, AU_DEC_ID1, TRUE, 0);
6531 HAL_AUDIO_DecWriteMaskByte((REG_M2D_MAILBOX_SPDIF_CTRL+1), 0x40, 0x40);
6532 #endif
6533 }
6534
6535 break;
6536 }
6537
6538 case HDMI_OUT_PCM:
6539 default:
6540 {
6541 /* PCM */
6542 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, AU_DEC_ID1, 1, 0); /* PCM Mode */
6543 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, AU_DEC_ID3, 1, 0); /* PCM Mode */
6544 HAL_AUDIO_WriteMaskByte((REG_M2D_MAILBOX_SPDIF_CTRL+1), 0x20, 0x00); /* PCM Mode */
6545 HAL_AUDIO_WriteMaskByte(0x2CB1, 0x04, 0x00);
6546 HAL_AUDIO_WriteMaskByte(0x2C48, 0x80, 0x00);
6547
6548 break;
6549 }
6550 }
6551
6552 HAL_AUDIO_Set_DecimationMode(AUDIO_HDMI_OUTPUT, u8NonPcmPath);
6553 g_AudioVars2->g_HDMINonPcmPath = u8NonPcmPath;
6554
6555 // For STB power saving
6556 HAL_AUDIO_DSPPowerSaving(outType_tmp);
6557 }
6558
6559 ////////////////////////////////////////////////////////////////////////////////
6560 /// @brief \b Function \b Name: HAL_AUDIO_DSPPowerSaving()
6561 /// @brief \b Function \b Description: For DSP change clock from 284Mhz to 364.5Mhz
6562 /// @param <IN> \b HDMI_TX_OUTPUT_TYPE outType_tmp
6563 /// @param <OUT> \b NONE :
6564 /// @param <RET> \b NONE :
6565 /// @param <GLOBAL> \b NONE :
6566 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DSPPowerSaving(HDMI_TX_OUTPUT_TYPE outType_tmp)6567 void HAL_AUDIO_DSPPowerSaving(HDMI_TX_OUTPUT_TYPE outType_tmp)
6568 {
6569 MS_BOOL u8DspPowerSaveMode = FALSE;
6570
6571 // for DSP Power saving
6572 if ((HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_STOP) &&
6573 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_STOP) )
6574 {// Decode stop
6575 u8DspPowerSaveMode = TRUE;
6576 }
6577 else
6578 {// Decode
6579 if(outType_tmp == HDMI_OUT_PCM)
6580 u8DspPowerSaveMode = TRUE;
6581 else
6582 u8DspPowerSaveMode = FALSE;
6583 }
6584
6585 if(u8DspPowerSaveMode == TRUE)
6586 {//DSP = 283.5Mhz
6587 // Mute
6588 // HW Reg
6589 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1f, 0x14);
6590 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x00);
6591 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
6592 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x00);
6593 // 283.5Mhz
6594 HAL_AUDIO_WriteMaskByte(0x2DC0, 0xFF, 0x8C); //(283.5/2 - 1) = 140.75 = 0x8C
6595 HAL_AUDIO_WriteMaskByte(0x2DC1, 0xFF, 0x00);
6596 // Un-Mute
6597 }
6598 else
6599 {//DSP = 364.5Mhz
6600 // Mute
6601 // HW Reg
6602 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x1f, 0x1a);
6603 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x40, 0x40);
6604 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x00);
6605 HAL_AUDIO_AbsWriteMaskByte(REG_DSP_DFS_REG, 0x80, 0x80);
6606 // 364.5Mhz
6607 HAL_AUDIO_WriteMaskByte(0x2DC0, 0xFF, 0xB5); //(364.5/2 - 1) = 181.25 = 0xB5
6608 HAL_AUDIO_WriteMaskByte(0x2DC1, 0xFF, 0x00);
6609 // Un-Mute
6610 }
6611 }
6612
6613 ////////////////////////////////////////////////////////////////////////////////
6614 /// @brief \b Function \b Name: HAL_AUDIO_PCMCaptureInit()
6615 /// @brief \b Function \b Description: Select source for pcm capture
6616 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6617 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6618 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6619 /// @param <RET> \b NONE :
6620 /// @param <GLOBAL> \b NONE :
6621 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID,const AUDIO_CAPTURE_SOURCE_TYPE eSource)6622 MS_BOOL HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID, const AUDIO_CAPTURE_SOURCE_TYPE eSource)
6623 {
6624 MS_BOOL ret = TRUE;
6625
6626 switch(eID)
6627 {
6628 case E_DEVICE0:
6629 g_pcm_capture_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
6630 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6631 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6632 break;
6633
6634 case E_DEVICE1:
6635 g_pcm_capture2_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
6636 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6637 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6638 break;
6639
6640 case E_DEVICE2:
6641 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6642 MP3Encode_baseaddr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + ASND_DSP_DDR_SIZE + OFFSET_MP3_ENC_DRAM_BASE ;
6643 break;
6644
6645 default:
6646 printf("\r\n =====PCMCapture_Init : unsupported DEVICE TYPE!!!=======");
6647 ret = FALSE;
6648 break;
6649 }
6650
6651 return ret;
6652 }
6653
6654 ////////////////////////////////////////////////////////////////////////////////
6655 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Start()
6656 /// @brief \b Function \b Description: captrue pcm data to DDR
6657 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6658 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6659 /// @param <RET> \b NONE :
6660 /// @param <GLOBAL> \b NONE :
6661 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)6662 MS_BOOL HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)
6663 {
6664 MS_BOOL ret = TRUE;
6665
6666 switch(eID)
6667 {
6668 case E_DEVICE0:
6669 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); // start
6670 break;
6671
6672 case E_DEVICE1:
6673 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); //start
6674 break;
6675
6676 case E_DEVICE2:
6677 HAL_AUDIO_DigitalOut_Set_Encode(MP3_ENCODE, TRUE);
6678 MP3EncodeReadIndex = (MS_U32)HAL_AUDIO_ReadReg(REG_MPEG_ENCODER_BUF_IDX);
6679 break;
6680
6681 default:
6682 printf("\r\n =====PCMCapture_Start : unsupported DEVICE TYPE!!!=======");
6683 ret = FALSE;
6684 break;
6685 }
6686
6687 return ret;
6688 }
6689
6690
6691 ////////////////////////////////////////////////////////////////////////////////
6692 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Stop()
6693 /// @brief \b Function \b Description: stop captrue pcm data from DDR
6694 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6695 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6696 /// @param <RET> \b NONE :
6697 /// @param <GLOBAL> \b NONE :
6698 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)6699 MS_BOOL HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)
6700 {
6701 MS_BOOL ret = TRUE;
6702 MS_U8 flagCount = 0;
6703
6704 switch(eID)
6705 {
6706 case E_DEVICE0:
6707 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0); // stop
6708 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0);
6709 do
6710 {
6711 MsOS_DelayTask(2);
6712 flagCount ++;
6713 if (flagCount > 100)
6714 {
6715 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6716 break;
6717 }
6718 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) > 0);
6719 break;
6720
6721 case E_DEVICE1:
6722 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0); //stop
6723 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0);
6724 do
6725 {
6726 MsOS_DelayTask(2);
6727 flagCount ++;
6728 if (flagCount > 100)
6729 {
6730 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6731 break;
6732 }
6733 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) > 0);
6734 break;
6735
6736 case E_DEVICE2:
6737 HAL_AUDIO_DigitalOut_Set_Encode(MP3_ENCODE, FALSE);
6738 MP3EncodeReadIndex = 0;
6739 break;
6740
6741 default:
6742 printf("\r\n =====PCMCapture_Stop : unsupported DEVICE TYPE!!!=======");
6743 ret = FALSE;
6744 break;
6745 }
6746
6747 return ret;
6748 }
6749
6750
6751 ////////////////////////////////////////////////////////////////////////////////
6752 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Read()
6753 /// @brief \b Function \b Description: captrue pcm data from DDR to device
6754 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6755 /// @param <IN> \b void* : destination buffer pointer
6756 /// @param <IN> \b MS_U32 : buffer size need transfered in byte
6757 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6758 /// @param <RET> \b NONE :
6759 /// @param <GLOBAL> \b NONE :
6760 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID,void * buffer,const MS_U32 bytes)6761 MS_BOOL HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID, void* buffer, const MS_U32 bytes)
6762 {
6763 MS_BOOL ret = TRUE;
6764 MS_VIRT buffer_tmp = (MS_VIRT)buffer;
6765 MS_U32 request_size = bytes;
6766 MS_U32 read_ptr_mailbox = 0;
6767 MS_U32 write_ptr_mailbox = 0;
6768 MS_PHY pcm_capture_base_addr_tmp = 0;
6769 MS_PHY pcm_capture_read_addr_tmp = 0;
6770 MS_PHY pcm_capture_write_addr_tmp = 0;
6771 MS_U32 mp3_encode_read_addr_tmp = 0;
6772 MS_S32 avail_size = 0;
6773
6774 switch(eID)
6775 {
6776 case E_DEVICE0:
6777 {
6778 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE_DDR_RdPtr;
6779 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE_DDR_WrPtr;
6780 pcm_capture_base_addr_tmp = g_pcm_capture_base_addr;
6781 }
6782 break;
6783
6784 case E_DEVICE1:
6785 {
6786 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr;
6787 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr;
6788 pcm_capture_base_addr_tmp = g_pcm_capture2_base_addr;
6789 }
6790 break;
6791
6792 // mp3 encode capture
6793 case E_DEVICE2:
6794 {
6795 mp3_encode_read_addr_tmp = (MS_U32)HAL_AUDIO_ReadReg(REG_MPEG_ENCODER_BUF_IDX);
6796 avail_size = mp3_encode_read_addr_tmp - MP3EncodeReadIndex;
6797 if (avail_size < 0)
6798 {
6799 avail_size += MP3_ENC_DRAM_SIZE;
6800 }
6801 if(avail_size >= (MP3_ENC_DRAM_SIZE - MP3EncodeCopySize))
6802 {
6803 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\n\033[1;36m ===== MP3_ENC DATA OVERFLOW !!!=======\033[0m \n");
6804 MP3EncodeReadIndex = (MS_U32)HAL_AUDIO_ReadReg(REG_MPEG_ENCODER_BUF_IDX);
6805 ret = FALSE;
6806 return ret;
6807 }
6808 // if no enough data, do nothing.
6809 if (avail_size < request_size)
6810 {
6811 ret = FALSE;
6812 return ret;
6813 }
6814
6815 mp3_encode_read_addr_tmp = MP3Encode_baseaddr + MP3EncodeReadIndex;
6816 //copy data to destination.
6817 do
6818 {
6819 MS_U32 size_tmp = (MP3Encode_baseaddr + MP3_ENC_DRAM_SIZE) - mp3_encode_read_addr_tmp;
6820
6821 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
6822 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
6823
6824 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(mp3_encode_read_addr_tmp), size_tmp);
6825 MsOS_FlushMemory();
6826
6827 mp3_encode_read_addr_tmp += size_tmp;
6828 if (mp3_encode_read_addr_tmp == (MP3Encode_baseaddr + MP3_ENC_DRAM_SIZE))
6829 mp3_encode_read_addr_tmp = MP3Encode_baseaddr;
6830
6831 buffer_tmp += size_tmp;
6832 avail_size -= size_tmp;
6833 request_size -= size_tmp;
6834
6835 } while (request_size > 0);
6836 //update read pointer
6837 MP3EncodeReadIndex = mp3_encode_read_addr_tmp - MP3Encode_baseaddr;
6838 return ret;
6839 }
6840 break;
6841
6842 default:
6843 {
6844 printf("\r\n =====PCMCapture_Read : unsupported DEVICE TYPE!!!=======\n");
6845 ret = FALSE;
6846 }
6847 break;
6848 }
6849
6850 if (ret == FALSE)
6851 return ret;
6852
6853 //get read & write pointer
6854 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(read_ptr_mailbox) * BYTES_IN_MIU_LINE);
6855 pcm_capture_write_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(write_ptr_mailbox) * BYTES_IN_MIU_LINE);
6856 avail_size = (MS_S32)(pcm_capture_write_addr_tmp - pcm_capture_read_addr_tmp);
6857 if (avail_size < 0)
6858 {
6859 avail_size += (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE);
6860 }
6861
6862 // if overflow , return false
6863 if (avail_size >= ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE - DSP2_PCM_CAPTURE_COPY_LINESIZE) * BYTES_IN_MIU_LINE))
6864 {
6865 printf("\r\n ===== PCM DATA OVERFLOW !!!=======\n");
6866
6867 HAL_AUDIO_PCMCapture_Stop(eID);
6868 HAL_AUDIO_PCMCapture_Start(eID);
6869 ret = FALSE;
6870 return ret;
6871 }
6872
6873 // if no enough data, do nothing.
6874 if (avail_size < request_size)
6875 {
6876 ret = FALSE;
6877 return ret;
6878 }
6879
6880 //copy data to destination.
6881 do
6882 {
6883 MS_U32 size_tmp = (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)) - pcm_capture_read_addr_tmp;
6884
6885 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
6886 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
6887
6888 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(pcm_capture_read_addr_tmp), size_tmp);
6889 MsOS_FlushMemory();
6890
6891 pcm_capture_read_addr_tmp += size_tmp;
6892 if (pcm_capture_read_addr_tmp == (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)))
6893 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp;
6894
6895 buffer_tmp += size_tmp;
6896 avail_size -= size_tmp;
6897 request_size -= size_tmp;
6898
6899 } while (request_size > 0);
6900
6901 //update read pointer
6902 HAL_AUDIO_WriteReg(read_ptr_mailbox, ((pcm_capture_read_addr_tmp - pcm_capture_base_addr_tmp) / BYTES_IN_MIU_LINE));
6903
6904 return ret;
6905 }
6906
6907 ////////////////////////////////////////////////////////////////////////////////
6908 /// @brief \b Function \b Name: HAL_AUDIO_SetDataCaptureSource()
6909 /// @brief \b Function \b Description: Select source for data capture
6910 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6911 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6912 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6913 /// @param <RET> \b NONE :
6914 /// @param <GLOBAL> \b NONE :
6915 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID,AUDIO_CAPTURE_SOURCE_TYPE eSource)6916 MS_BOOL HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID, AUDIO_CAPTURE_SOURCE_TYPE eSource)
6917 {
6918 MS_U32 u32ControlAddress;
6919 MS_BOOL ret = TRUE;
6920
6921 HALAUDIO_CHECK_SHM_INIT;
6922
6923 switch(eID)
6924 {
6925 case E_DEVICE0:
6926 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL;
6927 break;
6928
6929 case E_DEVICE1:
6930 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
6931 break;
6932
6933 case E_DEVICE2:
6934 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
6935 break;
6936
6937 default:
6938 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
6939 return FALSE;
6940 }
6941
6942 switch(eSource)
6943 {
6944 case E_CAPTURE_CH5:
6945 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH5);
6946 break;
6947
6948 case E_CAPTURE_CH6:
6949 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH6);
6950 break;
6951
6952 case E_CAPTURE_CH7:
6953 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH7);
6954 break;
6955
6956 case E_CAPTURE_CH8:
6957 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH8);
6958 break;
6959
6960 case E_CAPTURE_ADC:
6961 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
6962 break;
6963
6964 case E_CAPTURE_ADC2:
6965 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
6966 break;
6967
6968 case E_CAPTURE_PCM_SE:
6969 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_Raw_Delay_SE);
6970 break;
6971
6972 case E_CAPTURE_MIXER:
6973 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_MIXER);
6974 break;
6975
6976 case E_CAPTURE_ADC1_AUIN0_INPUT:
6977 case E_CAPTURE_ADC1_AUIN1_INPUT:
6978 case E_CAPTURE_ADC1_AUIN2_INPUT:
6979 case E_CAPTURE_ADC1_AUIN3_INPUT:
6980 case E_CAPTURE_ADC1_AUIN4_INPUT:
6981 case E_CAPTURE_ADC1_AUIN5_INPUT:
6982 case E_CAPTURE_ADC1_AUMIC_INPUT:
6983 {
6984 MS_U8 u8temp = 0;
6985
6986 //check if ADC1 is occupied by main or sub channel
6987 if((LONIBBLE(g_AudioVars2->AudioSrcType) == 2 || LONIBBLE(g_AudioVars2->AudioSubSrcType) == 2))
6988 {
6989 printf("===The audio capture setting is failed by the following reason:=== \n");
6990 printf("The input setting of ADC1 is occupied by main or sub channel\n");
6991 ret = FALSE;
6992 break;
6993 }
6994
6995 //switch source of ADC1
6996 if (eSource == E_CAPTURE_ADC1_AUIN0_INPUT)
6997 {
6998 u8temp = 0x00;
6999 }
7000 else if (eSource == E_CAPTURE_ADC1_AUIN1_INPUT)
7001 {
7002 u8temp = 0x01;
7003 }
7004 else if (eSource == E_CAPTURE_ADC1_AUIN2_INPUT)
7005 {
7006 u8temp = 0x02;
7007 }
7008 else if (eSource == E_CAPTURE_ADC1_AUIN3_INPUT)
7009 {
7010 u8temp = 0x03;
7011 }
7012 else if (eSource == E_CAPTURE_ADC1_AUIN4_INPUT)
7013 {
7014 u8temp = 0x04;
7015 }
7016 else if (eSource == E_CAPTURE_ADC1_AUIN5_INPUT)
7017 {
7018 u8temp = 0x05;
7019 }
7020 else if (eSource == E_CAPTURE_ADC1_AUMIC_INPUT)
7021 {
7022 u8temp = 0x07;
7023 }
7024
7025 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xE0, (u8temp<<5));
7026 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
7027 break;
7028 }
7029
7030 case E_CAPTURE_ADC2_AUIN0_INPUT:
7031 case E_CAPTURE_ADC2_AUIN1_INPUT:
7032 case E_CAPTURE_ADC2_AUIN2_INPUT:
7033 case E_CAPTURE_ADC2_AUIN3_INPUT:
7034 case E_CAPTURE_ADC2_AUIN4_INPUT:
7035 case E_CAPTURE_ADC2_AUIN5_INPUT:
7036 case E_CAPTURE_ADC2_AUMIC_INPUT:
7037 {
7038 MS_U8 u8temp = 0;
7039
7040 //check if ADC2 is occupied by main or sub channel
7041 if((LONIBBLE(g_AudioVars2->AudioSrcType) == 9 || LONIBBLE(g_AudioVars2->AudioSubSrcType) == 9))
7042 {
7043 printf("===The audio capture setting is faiedl by the following reason:=== \n");
7044 printf("The input setting of ADC2 is occupied by main or sub channel \n");
7045 ret = FALSE;
7046 break;
7047 }
7048
7049 //switch source of ADC2
7050 if (eSource == E_CAPTURE_ADC2_AUIN0_INPUT)
7051 {
7052 u8temp = 0x00;
7053 }
7054 else if (eSource == E_CAPTURE_ADC2_AUIN1_INPUT)
7055 {
7056 u8temp = 0x01;
7057 }
7058 else if (eSource == E_CAPTURE_ADC2_AUIN2_INPUT)
7059 {
7060 u8temp = 0x02;
7061 }
7062 else if (eSource == E_CAPTURE_ADC2_AUIN3_INPUT)
7063 {
7064 u8temp = 0x03;
7065 }
7066 else if (eSource == E_CAPTURE_ADC2_AUIN4_INPUT)
7067 {
7068 u8temp = 0x04;
7069 }
7070 else if (eSource == E_CAPTURE_ADC2_AUIN5_INPUT)
7071 {
7072 u8temp = 0x05;
7073 }
7074 else if (eSource == E_CAPTURE_ADC2_AUMIC_INPUT)
7075 {
7076 u8temp = 0x07;
7077 }
7078 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x1C, (u8temp<<2) );
7079 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
7080 break;
7081 }
7082
7083 default:
7084 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
7085 ret = FALSE;
7086 break;
7087 }
7088
7089 return ret;
7090 }
7091
_AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId)7092 MS_BOOL _AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId)
7093 {
7094 return TRUE;
7095 }
7096
AU_GetDecID(AUDIO_DEC_ID * DecPriority,AudioDecStatus_t * p_AudioDecStatus)7097 AUDIO_DEC_ID AU_GetDecID(AUDIO_DEC_ID *DecPriority, AudioDecStatus_t * p_AudioDecStatus)
7098 {
7099 #if defined (CONFIG_UTOPIA_ANDROID_L)
7100 MS_U8 u8Index = 0;
7101 MS_U8 u8Loop = 0;
7102 #else
7103 int u8Index = 0;
7104 int u8Loop = 0;
7105 #endif
7106 AUDIO_DEC_ID DecID = AU_DEC_INVALID;
7107
7108 #ifdef ROLLS_ROYCE
7109 if(p_AudioDecStatus->eAudio_Force_ID > AUDIO_FORCE_INVALID)
7110 {
7111 switch(p_AudioDecStatus->eAudio_Force_ID)
7112 {
7113 case AUDIO_FORCE_ID1:
7114 {
7115 DecID = AU_DEC_ID1;
7116 }
7117 break;
7118 case AUDIO_FORCE_ID2:
7119 {
7120 DecID = AU_DEC_ID2;
7121 }
7122 break;
7123 case AUDIO_FORCE_ID3:
7124 {
7125 DecID = AU_DEC_ID3;
7126 }
7127 break;
7128 default:
7129 {
7130 DecID = AUDIO_FORCE_INVALID;
7131 }
7132 break;
7133 }
7134 }
7135 else
7136 #endif
7137 {
7138 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7139 {
7140 u8Index = AU_DEC_MAX - 1;
7141 }
7142
7143 do
7144 {
7145 DecID = DecPriority[u8Index];
7146 if (DecID != AU_DEC_INVALID)
7147 {
7148 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7149 if ((HAL_MAD_GetAudioCapability(DecID, p_AudioDecStatus) == TRUE) &&
7150 (g_AudioVars2->AudioDecStatus[DecID].bConnect == FALSE))
7151 {
7152 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7153 break;
7154 }
7155 }
7156
7157 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7158 {
7159 u8Index--;
7160 }
7161 else
7162 {
7163 u8Index++;
7164 }
7165
7166 u8Loop++;
7167 } while (u8Loop < AU_DEC_MAX);
7168 }
7169
7170
7171 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7172 return DecID;
7173 }
7174
HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)7175 AUDIO_DEC_ID HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)
7176 {
7177 AUDIO_DEC_ID DecRet = AU_DEC_INVALID;
7178
7179 switch (p_AudioDecStatus->eSourceType)
7180 {
7181 case E_AUDIO_INFO_HDMI_IN:
7182 DecRet = AU_GetDecID(HDMIDecPriority, p_AudioDecStatus);
7183 break;
7184 case E_AUDIO_INFO_DTV_IN:
7185 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7186 break;
7187 case E_AUDIO_INFO_MM_IN:
7188 case E_AUDIO_INFO_GAME_IN:
7189 if (p_AudioDecStatus->eMMType == AUDIO_MM_VD)
7190 {
7191 DecRet = AU_GetDecID(VDDecPriority, p_AudioDecStatus);
7192 }
7193 else
7194 {
7195 DecRet = AU_GetDecID(MMDecPriority, p_AudioDecStatus);
7196 }
7197 break;
7198 default:
7199 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7200 break;
7201 }
7202
7203 switch (DecRet)
7204 {
7205 case AU_DEC_ID1:
7206 p_AudioDecStatus->eAfifoSource = E_AFIFO_0;
7207 break;
7208 case AU_DEC_ID2:
7209 p_AudioDecStatus->eAfifoSource = E_AFIFO_1;
7210 break;
7211 case AU_DEC_ID3:
7212 p_AudioDecStatus->eAfifoSource = E_AFIFO_2;
7213 break;
7214 default:
7215 p_AudioDecStatus->eAfifoSource = E_AFIFO_MAX;
7216 break;
7217 }
7218
7219 printf("DecID = %d %s() %d \n",DecRet,__FUNCTION__,__LINE__);
7220 return DecRet;
7221 }
7222
HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId,AudioDecStatus_t * p_AudioDecStatus)7223 MS_BOOL HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus)
7224 {
7225 AUDIO_DSP_ID DSP_id = AUDIO_DSP_ID_ALL;
7226 MS_BOOL bRet = FALSE;
7227
7228 HALAUDIO_CHECK_SHM_INIT;
7229
7230 switch(p_AudioDecStatus->eStcSource)
7231 {
7232 case E_TSP_0:
7233 if (DecId == AU_DEC_ID1)
7234 {
7235 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECTION, AU_DEC_ID1, 0, 0);
7236 }
7237 else if(DecId == AU_DEC_ID3)
7238 {
7239 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECTION, AU_DEC_ID3, 0, 0);
7240 }
7241 break;
7242
7243 case E_TSP_1:
7244 if (DecId == AU_DEC_ID1)
7245 {
7246 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECTION, AU_DEC_ID1, 1, 0);
7247 }
7248 else if(DecId == AU_DEC_ID3)
7249 {
7250 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECTION, AU_DEC_ID3, 1, 0);
7251 }
7252 break;
7253 case E_TSP_2:
7254 case E_TSP_3:
7255 case E_TSP_MAX:
7256 break;
7257 }
7258
7259 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\033[1;31m [%s: %d][DecId = %d, eAudFormat = %d, g_AudioVars2->AudioDecStatus[DecId].eAudFormat = %d] \033[0m \n", __FILE__, __LINE__,
7260 // DecId,
7261 // p_AudioDecStatus->eAudFormat,
7262 // g_AudioVars2->AudioDecStatus[DecId].eAudFormat);
7263 if (p_AudioDecStatus->eGroup == E_CONNECT_MAIN)
7264 {
7265 g_AudioVars2->eAudioSource = p_AudioDecStatus->eSourceType;
7266 }
7267
7268 if ((DecId == AU_DEC_ID1) && (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_DTV_IN))
7269 {
7270 HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT,AUDIO_PATH_5);
7271 }
7272
7273 //patch for curry sub dtv because of hw unsupport dual dtv.------chasen.cai
7274 if ((DecId == AU_DEC_ID3)
7275 && (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_DTV_IN)
7276 && (p_AudioDecStatus->eGroup == E_CONNECT_SUB))
7277 {
7278 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_ES2_IsUsedBy_Dual, AU_DEC_ID3, 1, 0);
7279 }
7280
7281 if((g_AudioVars2->AudioDecStatus[DecId].eAudFormat == p_AudioDecStatus->eAudFormat) &&
7282 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == p_AudioDecStatus->eSourceType) &&
7283 (g_AudioVars2->AudioDecStatus[DecId].eGroup == p_AudioDecStatus->eGroup) &&
7284 (g_AudioVars2->AudioDecStatus[DecId].eStcSource == p_AudioDecStatus->eStcSource) &&
7285 (g_AudioVars2->AudioDecStatus[DecId].bIsAD == p_AudioDecStatus->bIsAD))
7286 {
7287 HALAUDIO_PRINT("%s() - DSP code is the same\n",__FUNCTION__);
7288 return bRet;
7289 }
7290
7291 if (DecId == AU_DEC_ID3)
7292 {
7293 DSP_id = AUDIO_DSP_ID_SND;
7294 }
7295 else if (DecId == AU_DEC_ID1)
7296 {
7297 DSP_id = AUDIO_DSP_ID_DEC;
7298 }
7299 else if (DecId == AU_DEC_ID2)
7300 {
7301 // Patch, SIF only decode in SND_DSP, but this enum is same as AUDIO_DSP_ID_SND
7302 DSP_id = AUDIO_DSP_ID_ALL;
7303 }
7304
7305 HAL_MAD_DvbFLockSynthesizer_En();
7306
7307 g_AudioVars2->AudioDecStatus[DecId].eDSPId = DSP_id;
7308 p_AudioDecStatus->eDSPId = DSP_id;
7309
7310 switch ( p_AudioDecStatus->eAudFormat)
7311 {
7312 case MSAPI_AUD_DVB_MPEG:
7313 case MSAPI_AUD_DVB_AC3:
7314 case MSAPI_AUD_DVB_AC3P:
7315 case MSAPI_AUD_DVB_MP3:
7316 case MSAPI_AUD_DVB_AAC:
7317 case MSAPI_AUD_DVB_XPCM:
7318 case MSAPI_AUD_DVB_RA8LBR:
7319 case MSAPI_AUD_DVB_WMA:
7320 case MSAPI_AUD_DVB_DTS:
7321 case MSAPI_AUD_DVB_DTSLBR:
7322 case MSAPI_AUD_DVB_DTSHDADO:
7323 case MSAPI_AUD_DVB_MS10_DDT:
7324 case MSAPI_AUD_DVB_MS10_DDC:
7325 case MSAPI_AUD_DVB_WMA_PRO:
7326 case MSAPI_AUD_DVB_FLAC:
7327 case MSAPI_AUD_DVB_VORBIS:
7328 case MSAPI_AUD_DVB_AMR_NB:
7329 case MSAPI_AUD_DVB_AMR_WB:
7330 case MSAPI_AUD_DVB_DRA:
7331 case MSAPI_AUD_DVB_ES_Bypass:
7332 bRet = HAL_AUDIO_SetSystem2(DecId, p_AudioDecStatus->eAudFormat);
7333 break;
7334
7335 default:
7336 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, p_AudioDecStatus->eAudFormat);
7337 break;
7338 }
7339
7340 return bRet;
7341 }
7342
_AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId)7343 MS_BOOL _AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId)
7344 {
7345 return TRUE;
7346 }
7347
HAL_AUDIO_ReloadCode(AUDIO_DSP_ID id,AUDIO_DSP_CODE_TYPE code_type)7348 MS_BOOL HAL_AUDIO_ReloadCode(AUDIO_DSP_ID id, AUDIO_DSP_CODE_TYPE code_type)
7349 {
7350 return TRUE;
7351 }
7352
HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id,void * pau_info)7353 MS_BOOL HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id, void * pau_info)
7354 {
7355 return TRUE;
7356 }
7357
HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId,En_DVB_decSystemType Param)7358 MS_BOOL HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId, En_DVB_decSystemType Param)
7359 {
7360 MS_U32 regDecoderType = REG_R2_DECODE1_TYPE;
7361 MS_BOOL bRet = TRUE;
7362
7363 if(DecId == AU_DEC_ID3)
7364 {
7365 regDecoderType = REG_R2_DECODE2_TYPE;
7366 }
7367 else if (DecId == AU_DEC_ID1)
7368 {
7369 regDecoderType = REG_R2_DECODE1_TYPE;
7370 }
7371 else if (DecId == AU_DEC_ID2)
7372 {
7373 // AU_DEC_ID2 only for ATV SIF
7374 // For other case should not use AU_DEC_ID2
7375 return bRet;
7376 }
7377
7378 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = Param;
7379
7380 switch ( Param )
7381 {
7382 case MSAPI_AUD_DVB_MPEG:
7383 case MSAPI_AUD_DVB_MP3:
7384 HAL_AUR2_WriteByte(regDecoderType, adec_type_mpeg);
7385 if(DecId == AU_DEC_ID3)
7386 {
7387 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
7388 }
7389 else
7390 {
7391 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
7392 }
7393 break;
7394
7395 case MSAPI_AUD_DVB_MS10_DDC:
7396 case MSAPI_AUD_DVB_AC3P:
7397 case MSAPI_AUD_DVB_AC3:
7398 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7399 HAL_AUR2_WriteByte(regDecoderType, adec_type_ac3);
7400 if(DecId == AU_DEC_ID3)
7401 {
7402 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
7403 }
7404 else
7405 {
7406 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
7407 }
7408 break;
7409
7410 case MSAPI_AUD_DVB_AAC:
7411 case MSAPI_AUD_DVB_MS10_DDT:
7412 if (g_AudioVars2->DolbyAACFlag == 1)
7413 {
7414 HAL_AUR2_WriteByte(regDecoderType, adec_type_aac);
7415 }
7416 else
7417 {
7418 HAL_AUR2_WriteByte(regDecoderType, adec_type_gaac);
7419 }
7420 HAL_MAD2_ReLoadCode(AU_DVB2_STANDARD_DDE);
7421 if(DecId == AU_DEC_ID3)
7422 {
7423 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
7424 }
7425 else
7426 {
7427 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
7428 }
7429 break;
7430
7431 case MSAPI_AUD_DVB_XPCM:
7432 HAL_AUR2_WriteByte(regDecoderType, adec_type_xpcm);
7433 if(DecId == AU_DEC_ID3)
7434 {
7435 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
7436 }
7437 else
7438 {
7439 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
7440 }
7441 break;
7442
7443 case MSAPI_AUD_DVB_RA8LBR:
7444 HAL_AUR2_WriteByte(regDecoderType, adec_type_ra8);
7445 if(DecId == AU_DEC_ID3)
7446 {
7447 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7448 }
7449 else
7450 {
7451 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7452 }
7453 break;
7454
7455 case MSAPI_AUD_DVB_WMA:
7456 HAL_AUR2_WriteByte(regDecoderType, adec_type_wma);
7457 if(DecId == AU_DEC_ID3)
7458 {
7459 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA, TRUE);
7460 }
7461 else
7462 {
7463 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
7464 }
7465 break;
7466
7467 case MSAPI_AUD_DVB_DTS:
7468 case MSAPI_AUD_DVB_DTSLBR:
7469 case MSAPI_AUD_DVB_DTSHDADO:
7470 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7471 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7472 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7473 if(DecId == AU_DEC_ID3)
7474 {
7475 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7476 }
7477 else
7478 {
7479 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7480 }
7481 break;
7482
7483 case MSAPI_AUD_DVB_WMA_PRO:
7484 HAL_AUR2_WriteByte(regDecoderType, adec_type_wmap);
7485 if(DecId == AU_DEC_ID3)
7486 {
7487 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7488 }
7489 else
7490 {
7491 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7492 }
7493 break;
7494
7495 case MSAPI_AUD_DVB_DRA:
7496 HAL_AUR2_WriteByte(regDecoderType, adec_type_dra);
7497 if(DecId == AU_DEC_ID3)
7498 {
7499 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DRA, TRUE);
7500 }
7501 else
7502 {
7503 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
7504 }
7505 break;
7506
7507 case MSAPI_AUD_DVB_FLAC:
7508 HAL_AUR2_WriteByte(regDecoderType, adec_type_flac);
7509 if(DecId == AU_DEC_ID3)
7510 {
7511 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_FLAC, TRUE);
7512 }
7513 else
7514 {
7515 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
7516 }
7517 break;
7518
7519 case MSAPI_AUD_DVB_VORBIS:
7520 HAL_AUR2_WriteByte(regDecoderType, adec_type_vorbis);
7521 if(DecId == AU_DEC_ID3)
7522 {
7523 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7524 }
7525 else
7526 {
7527 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7528 }
7529 break;
7530
7531 case MSAPI_AUD_DVB_AMR_NB:
7532 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7533 if(DecId == AU_DEC_ID3)
7534 {
7535 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7536 }
7537 else
7538 {
7539 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7540 }
7541 break;
7542
7543 case MSAPI_AUD_DVB_AMR_WB:
7544 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7545 if(DecId == AU_DEC_ID3)
7546 {
7547 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7548 }
7549 else
7550 {
7551 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7552 }
7553 break;
7554
7555 case MSAPI_AUD_DVB_DolbyTrueHDBypass:
7556 HAL_AUR2_WriteByte(regDecoderType, adec_type_dolby_truhd_bypass); /* select r2 decoder to dolby TrueHD bypss */
7557 if(DecId == AU_DEC_ID3)
7558 {
7559 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DolbyTrueHD_Bypass, TRUE); //set decoder type for HDMI Tx handler
7560 }
7561 else
7562 {
7563 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DolbyTrueHD_Bypass, TRUE);
7564 }
7565 break;
7566
7567 case MSAPI_AUD_DVB_ES_Bypass:
7568 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy); // select r2 decoder to HDMI bypss
7569 if(DecId == AU_DEC_ID3)
7570 {
7571 HAL_AUDIO_SetDsp2CodeType(AU_DEC_ES_BYPASS, TRUE); //set decoder type for HDMI bypass
7572 }
7573 else
7574 {
7575 HAL_AUDIO_SetDspCodeType(AU_DEC_ES_BYPASS, TRUE);
7576 }
7577 break;
7578
7579 default:
7580 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, Param);
7581 break;
7582 }
7583
7584 return bRet;
7585 }
7586
7587 ////////////////////////////////////////////////////////////////////////////////
7588 /// @brief \b Function \b Name: HAL_AUDIO_GetDDRInfo()
7589 /// @brief \b Function \b Description: Return Audio DDR info
7590 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
7591 /// @param <IN> \b EN_AUDIO_DDRINFO : DDR info
7592 /// @param <OUT> \b MS_U32 : return DDR info
7593 /// @param <RET> \b NONE :
7594 /// @param <GLOBAL> \b NONE :
7595 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId,EN_AUDIO_DDRINFO DDRInfo)7596 MS_PHY HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo)
7597 {
7598 MS_PHY DDR_ADDR = 0;
7599 MS_PHY DDR_ADDR_LINE_BASE = 0;
7600 MS_PHY DDR_ADDR_TMP;
7601 MS_PHY DDR_Value = 0;
7602 if (DecId == AU_DEC_ID1)
7603 {
7604 switch(DDRInfo)
7605 {
7606 case E_AUD_MEMORY_BASE: //use DSP2 base instead
7607 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7608 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7609 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7610 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7611 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7612 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7613 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7614 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7615 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7616 DDR_Value = DDR_ADDR;
7617 break;
7618 case E_AUD_MEMORY_SIZE:
7619 //TODO
7620 break;
7621 default:
7622 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7623 break;
7624 }
7625 }
7626 else if(DecId == AU_DEC_ID3)
7627 {
7628 switch(DDRInfo)
7629 {
7630 case E_AUD_MEMORY_BASE:
7631 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7632 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7633 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7634 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7635 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7636 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7637 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7638 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7639 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7640 DDR_Value = DDR_ADDR;
7641 break;
7642 case E_AUD_MEMORY_SIZE:
7643 //TODO
7644 break;
7645 default:
7646 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7647 break;
7648 }
7649 }
7650 else
7651 {
7652 HALAUDIO_ERROR ("%s: UN-KNOW DecId (0x%x) !!\r\n", __FUNCTION__, DecId);
7653 }
7654 return DDR_Value;
7655 }
7656
7657 ////////////////////////////////////////////////////////////////////////////////
7658 /// @brief \b Function \b Name: HAL_AUDIO_DumpDspInfo()
7659 /// @brief \b Function \b Description: Dump DSP infomation
7660 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DumpDspInfo(void)7661 void HAL_AUDIO_DumpDspInfo(void)
7662 {
7663 MS_U32 tmp_H, tmp_L, tmp_M;
7664 MS_U32 result = 0;
7665 MS_U32 ES_Lvl, PCM_Lvl;
7666 static MS_U32 preSysTime, prv_mmFile_APTS;
7667 MS_U32 sysTime, mmFile_APTS;
7668
7669 if(g_AudioDumpInfoCtrl == Audio_DumpInfo_Off)
7670 {
7671 return;
7672 }
7673
7674 ES_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, AU_DEC_ID1);
7675 PCM_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_LEVEL, AU_DEC_ID1)/5;
7676
7677 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Avsync) != 0)
7678 {
7679 sysTime = MsOS_GetSystemTime();
7680 printf("[%08u]", sysTime);
7681
7682 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, AU_DEC_ID1)&0xFFFF;
7683 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
7684
7685 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, AU_DEC_ID1)&0xFFFF;
7686 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, AU_DEC_ID1)&0xFFFF;
7687 printf("PCM=%04X(%04X,%04X)|", PCM_Lvl, tmp_H, tmp_L);
7688
7689 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, AU_DEC_ID1)&0x1;
7690 printf("play=%X", tmp_L);
7691
7692 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, AU_DEC_ID1)&0xFFFF;
7693 printf("<%04X>,", tmp_L);
7694
7695 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, AU_DEC_ID1)&0x0F;
7696 tmp_M = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, 0, 0)&0x0F;
7697 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, AU_DEC_ID1)&0x0F;
7698 printf("State=%X,%X(%X)|", tmp_L,tmp_M, tmp_H);
7699
7700 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7701 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7702 printf("frmCnt:%04X,", tmp_L);
7703 printf("%04X,", tmp_H);
7704
7705 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, AU_DEC_ID1)&0x0000FF;
7706 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, AU_DEC_ID1)&0x0000FF;
7707 printf("%02X,", tmp_L);
7708 printf("%02X,", tmp_H);
7709
7710 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_1STPTS_CNT, AU_DEC_ID1)&0x00FF;
7711 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_STC_CNT, AU_DEC_ID1)&0x00FF;
7712 tmp_M = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_FLUSH_CNT, AU_DEC_ID1)&0x00FF;
7713 printf("%02X,%02X,%02X|", tmp_L, tmp_H, tmp_M);
7714
7715 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_WR_IDX, AU_DEC_ID1)&0xF;
7716 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_RD_IDX, AU_DEC_ID1)&0xF;
7717 printf("tag:%01X,%01X|", tmp_L, tmp_H);
7718
7719 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_OFFSET, AU_DEC_ID1)&0x00FFFFFF;
7720 printf("AvDly=%05X,", tmp_L);
7721
7722 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_STC, AU_DEC_ID1);
7723 printf("STC=%d,", result/45);
7724
7725 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, AU_DEC_ID1);
7726 printf("PTS=%d,", result/45);
7727
7728 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, AU_DEC_ID1);
7729 printf("cPTS=%d,", result/45);
7730
7731 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
7732 printf("|Td=%x\n", result/90);
7733 }
7734
7735 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Dec1) != 0)
7736 {
7737 sysTime = MsOS_GetSystemTime();
7738 printf("[%08u]", sysTime);
7739
7740 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, AU_DEC_ID1)&0xFFFF;
7741 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
7742
7743 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, AU_DEC_ID1)&0xFF;
7744 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, AU_DEC_ID1)&0xFFFF;
7745 printf("PCM=%04X(%04X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
7746
7747 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_TYPE);
7748 printf("ID=%02X,", tmp_L);
7749
7750 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_TYPE, AU_DEC_ID1)&0x00FF;
7751 printf("Type=%02X,", tmp_L);
7752
7753 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, AU_DEC_ID1)&0x00FFFFFF;
7754 printf("pState=%06X,", tmp_L);
7755
7756 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7757 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, AU_DEC_ID1)&0x00FF;
7758 printf("|Cmd=%02X,Stop=%02X|", tmp_L, tmp_H);
7759
7760 tmp_L = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER1_CFG);
7761 tmp_H = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER2_CFG);
7762 printf("Input_Mux:%02X,", tmp_L&0x7);
7763 printf("%02X,", tmp_H&0x7);
7764 printf("%02X|", (tmp_L>>16)&0x7);
7765
7766 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7767 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7768 printf("frmCnt:%04X,", tmp_L);
7769 printf("%04X,", tmp_H);
7770
7771 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, AU_DEC_ID1)&0x0000FF;
7772 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, AU_DEC_ID1)&0x0000FF;
7773 printf("%02X,", tmp_L);
7774 printf("%02X|", tmp_H);
7775
7776 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, AU_DEC_ID1)&0x0000FFFF;
7777 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, AU_DEC_ID1)&0x0000FFFF;
7778 printf("Call:%04X,", tmp_L);
7779 printf("sMiss:%04X|", tmp_H);
7780
7781 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, AU_DEC_ID1)&0x00FFFFFF;
7782 printf("pcm=%06X,", tmp_L);
7783
7784 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_R, AU_DEC_ID1)&0x00FFFFFF;
7785 printf("%06X|", tmp_L);
7786
7787 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, AU_DEC_ID1)&0x1;
7788 printf("play=%X\n", tmp_L);
7789 }
7790
7791
7792 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_IoInfo) != 0)
7793 {
7794 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH5_CFG)) & 0x000F;
7795 printf("CH5 mux=0x%02X,", tmp_L);
7796
7797 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH6_CFG)) & 0x000F;
7798 printf("Ch6 mux=0x%02X,", tmp_L);
7799
7800 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH7_CFG)) & 0x000F;
7801 printf("Ch7 mux=0x%02X", tmp_L);
7802
7803 // Not define
7804 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, AU_DEC_ID1)&0x00FFFFFF;
7805 printf("|DEC1=0x%06X,", tmp_L);
7806
7807 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, AU_DEC_ID3)&0x00FFFFFF;
7808 printf("DEC2=0x%06X", tmp_L);
7809
7810 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_RAW+0);
7811 printf("|CH5=0x%06X,", tmp_L);
7812
7813 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_MUL_CH6+0);
7814 printf("CH6=0x%06X,", tmp_L);
7815
7816 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_SCART+0);
7817 printf("CH7=0x%06X", tmp_L);
7818
7819 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_DAC1_OUT+0);
7820 printf("|DAC1=0x%06X,", tmp_L);
7821
7822 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_IIS1_OUT+0);
7823 printf("I2S=0x%06X,", tmp_L);
7824
7825 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_SPDIF_OUT+0);
7826 printf("SPDIF=0x%06X\n", tmp_L);
7827 }
7828
7829 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_AutoTest) != 0)
7830 {
7831 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1)&0x00FFFFFF;
7832 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1)&0x00FFFFFF;
7833 printf("[AutoTest][AUDIO][FrameCount][%d]\n", tmp_L);
7834 printf("[AutoTest][AUDIO][ErrorCount][%d]\n", tmp_H);
7835
7836 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, AU_DEC_ID1);
7837 printf("[AutoTest][AUDIO][SampleRate][%d]\n", tmp_L);
7838 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, AU_DEC_ID1);
7839 printf("[AutoTest][AUDIO][ACMod][%d]\n", tmp_L);
7840 }
7841
7842 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_mmFileAVsync) != 0)
7843 {
7844 sysTime = MsOS_GetSystemTime();
7845 printf("[%08u](%03u):", sysTime, sysTime - preSysTime);
7846 preSysTime = sysTime;
7847
7848 mmFile_APTS = HAL_MAD_GetCommInfo(Audio_Comm_infoType_1ms_PTS);
7849 printf("APTS:%07u(%03u)|", mmFile_APTS, mmFile_APTS - prv_mmFile_APTS);
7850 prv_mmFile_APTS = mmFile_APTS;
7851
7852 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, AU_DEC_ID1)&0xFFFF;
7853 printf("MM:%04X|", tmp_H);
7854
7855 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, AU_DEC_ID1)&0xFFFF;
7856 printf("ES=%04X(%04X),", ES_Lvl, tmp_L);
7857
7858 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, AU_DEC_ID1)&0xFF;
7859 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, AU_DEC_ID1)&0xFFFFFF;
7860 printf("PCM=%04X(%06X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
7861
7862 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7863 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, AU_DEC_ID1)&0x00FF;
7864 printf("Cmd=%02X,Stop=%02X,", tmp_L, tmp_H);
7865
7866 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, AU_DEC_ID1)&0x1;
7867 printf("play=%X", tmp_L);
7868
7869 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, AU_DEC_ID1)&0xFFFF;
7870 printf("<%04X>,", tmp_L);
7871
7872 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, AU_DEC_ID1)&0x0F;
7873 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, AU_DEC_ID1)&0x0F;
7874 printf("State=%X(%X)|", tmp_L, tmp_H);
7875
7876 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7877 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, AU_DEC_ID1)&0x0000FFFF;
7878 printf("frmCnt:%04X,", tmp_L);
7879 printf("%04X,", tmp_H);
7880
7881 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, AU_DEC_ID1)&0x0000FF;
7882 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, AU_DEC_ID1)&0x0000FF;
7883 printf("%02X,", tmp_L);
7884 printf("%02X|", tmp_H);
7885
7886 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_ID, DSP_MEM_TYPE_DM)&0x00FF;
7887 //printf("DEC_ID=%02X,", tmp_L);
7888
7889 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_DEC_TYPE, DSP_MEM_TYPE_DM)&0x00FF;
7890 //printf("Type=%02X,", tmp_L);
7891
7892 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, AU_DEC_ID1)&0x00FFFF;
7893 printf("pState=%04X,", tmp_L);
7894
7895 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, AU_DEC_ID1)&0x0000FF;
7896 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, AU_DEC_ID1)&0x00000FFF;
7897 printf("Call:%02X,", tmp_L);
7898 printf("Miss:%03X\n", tmp_H);
7899 }
7900
7901 }
7902
7903
7904 #ifndef MSOS_TYPE_NUTTX
HAL_AUDIO_ResetTeeInfoShmToDefault(void)7905 MS_BOOL HAL_AUDIO_ResetTeeInfoShmToDefault(void)
7906 {
7907 if (pAudioTeeInfoShm == NULL)
7908 {
7909 return FALSE;
7910 }
7911 memset(pAudioTeeInfoShm, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
7912 audio_tee_enabled = g_bAudioTeeEnabled;
7913 audio_tee_mbx_initialized = g_bAudioTeeMbxInitialized;
7914 dec_dsp_secure_tee_accessed = g_bDecDspSecureTeeAccessed;
7915 snd_dsp_secure_tee_accessed = g_bSndDspSecureTeeAccessed;
7916 return TRUE;
7917 }
7918
HAL_AUDIO_AllocateTeeInfoShm(void)7919 AUDIO_TEE_INFO_SHARE_MEM *HAL_AUDIO_AllocateTeeInfoShm(void)
7920 {
7921 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7922 MS_U32 u32ShmId = 0;
7923 AUDIO_TEE_INFO_SHARE_MEM *virtAddr = 0;
7924 MS_U32 u32BufSize = 0;
7925
7926 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, (MS_VIRT*)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
7927 {
7928 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7929
7930 if (pAudioTeeInfoShm->g_u32ClientCounter == 0)
7931 {
7932 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7933 HAL_AUDIO_ResetTeeInfoShmToDefault();
7934 }
7935 }
7936 else
7937 {
7938 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, (MS_VIRT*)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
7939 {
7940 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7941 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7942
7943 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7944 HAL_AUDIO_ResetTeeInfoShmToDefault();
7945 }
7946 else
7947 {
7948 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "SHM allocation for Audio TEE Info failed!\n");
7949 return NULL;
7950 }
7951 }
7952
7953 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7954 {
7955 g_bAudioTeeInfoShmInitFlag = TRUE;
7956 pAudioTeeInfoShm->g_u32ClientCounter++;
7957 }
7958 #else
7959 pAudioTeeInfoShm = &gAudioTeeInfoShm;
7960
7961 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7962 {
7963 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7964 g_bAudioTeeInfoShmInitFlag = TRUE;
7965
7966 HAL_AUDIO_ResetTeeInfoShmToDefault();
7967 pAudioTeeInfoShm->g_u32ClientCounter++;
7968 }
7969 #endif
7970 return pAudioTeeInfoShm;
7971 }
7972
HAL_AUDIO_DeAllocateTeeInfoShm(void)7973 MS_BOOL HAL_AUDIO_DeAllocateTeeInfoShm(void)
7974 {
7975 AUDIO_TEE_INFO_SHARE_MEM * pAUDIOShared = NULL;
7976
7977 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7978 MS_U32 u32ShmId = 0;
7979 MS_VIRT virtAddr = 0;
7980 MS_U32 u32BufSize = 0;
7981
7982 if (g_bAudioTeeInfoShmInitFlag == TRUE)
7983 {
7984 g_bAudioTeeInfoShmInitFlag = FALSE;
7985
7986 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, &virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
7987 {
7988 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : No AUDIO TEE Info SHM is created!\n", __FUNCTION__);
7989 return FALSE;
7990 }
7991
7992 pAUDIOShared = (AUDIO_TEE_INFO_SHARE_MEM *)virtAddr;
7993 pAUDIOShared->g_u32ClientCounter--;
7994
7995 if (pAUDIOShared->g_u32ClientCounter == 0)
7996 {
7997 printf("free Audio TEE Info SHM data ...\n");
7998
7999 #if defined(MSOS_TYPE_LINUX)
8000 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, u32ShmId) == TRUE)
8001 {
8002 HALAUDIO_PRINT("Audio TEE Info SHM data is freed\n");
8003 }
8004 else
8005 {
8006 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
8007 return FALSE;
8008 }
8009 #endif
8010 }
8011 }
8012 #else
8013 pAUDIOShared = &gAudioTeeInfoShm;
8014
8015 if (g_bAudioTeeInfoShmInitFlag == TRUE)
8016 {
8017 HALAUDIO_PRINT("free Audio TEE Info SHM data ...\n");
8018 g_bAudioTeeInfoShmInitFlag = FALSE;
8019
8020 memset(pAUDIOShared, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
8021 }
8022 #endif
8023
8024 return TRUE;
8025 }
8026
HAL_AUDIO_RegisterMBX(void)8027 MS_BOOL HAL_AUDIO_RegisterMBX(void)
8028 {
8029 MS_U8 ClassNum=0;
8030 MBX_Result result;
8031 MBX_CPU_ID eHKCPU;
8032 MS_U32 u32TimeoutMillSecs = 10000;
8033
8034 if (pAudioTeeInfoShm == NULL)
8035 return FALSE;
8036 if (audio_tee_mbx_initialized == TRUE)
8037 return TRUE;
8038
8039 #if 1
8040 eHKCPU = E_MBX_CPU_MIPS;
8041 if ( E_MBX_SUCCESS != MApi_MBX_Init(eHKCPU, E_MBX_ROLE_HK, u32TimeoutMillSecs))
8042 {
8043 DBG_AUDIO_ERROR("Error> MBX init failed !!\n");
8044 return FALSE;
8045 }
8046 else
8047 {
8048 MApi_MBX_Enable(TRUE);
8049 }
8050 #endif
8051
8052 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass (E_MBX_CPU_MIPS_VPE1, "MAD", (MS_U8 *)&ClassNum))
8053 {
8054 DBG_AUDIO_ERROR("MAD MApi_MBX_QueryDynamicClass fail\n");
8055
8056 return FALSE;
8057 }
8058 result = MApi_MBX_RegisterMSG(ClassNum, 10);
8059 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
8060 {
8061 DBG_AUDIO_ERROR("HAL_AUDIO_RegisterMBX fail");
8062 return FALSE;
8063 }
8064 else
8065 {
8066 TEE_MBX_MSG_CLASS_SET(ClassNum);
8067 DBG_AUDIO("HAL_AUDIO_RegisterMBX ok");
8068 return TRUE;
8069 }
8070 }
8071
HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)8072 TEE_TO_REE_MBX_ACK_MSG_TYPE HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)
8073 {
8074 MS_U8 u8Index;
8075 MBX_Result result;
8076 REE_TO_TEE_MBX_MSG_TYPE msg_type1 = REE_TO_TEE_MBX_MSG_NULL;
8077
8078 AUDIO_TEE_INFO_SHM_CHECK_NULL;
8079
8080 if (audio_tee_enabled == FALSE)
8081 {
8082 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8083 }
8084 if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_DEC) == (REE_TO_TEE_MBX_MSG_TYPE_DEC))
8085 {
8086 if (dec_dsp_secure_tee_accessed == FALSE)
8087 {
8088 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8089 }
8090 else
8091 {
8092 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_DEC);
8093 }
8094 }
8095 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_SE) == (REE_TO_TEE_MBX_MSG_TYPE_SE))
8096 {
8097 if (snd_dsp_secure_tee_accessed == FALSE)
8098 {
8099 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8100 }
8101 else
8102 {
8103 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_SE);
8104 }
8105 }
8106 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_GENERAL) == (REE_TO_TEE_MBX_MSG_TYPE_GENERAL))
8107 {
8108
8109 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
8110 }
8111
8112 if (audio_tee_mbx_initialized == FALSE)
8113 {
8114 return TEE_TO_REE_MBX_ACK_MSG_INVALID;
8115 }
8116 REE_TO_TEE_MBX_MSG_INIT;
8117 MBX_MSG_SET_CLASSID(ree_to_tee_mbx_msg, tee_mbx_msg_class);
8118 MBX_MSG_SET_CMD(ree_to_tee_mbx_msg, msg_type1);
8119
8120 result = MApi_MBX_SendMsg(&(ree_to_tee_mbx_msg));
8121 if (E_MBX_SUCCESS!= result)
8122 {
8123 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8124 }
8125 // Receive Reply ACK from TEE side.
8126 memset(&(tee_to_ree_mbx_msg), 0, sizeof(MBX_Msg));
8127 MBX_MSG_SET_CLASSID(tee_to_ree_mbx_msg, tee_mbx_msg_class);
8128 do
8129 {
8130 result = MApi_MBX_RecvMsg(tee_mbx_msg_class, &(tee_to_ree_mbx_msg), 2000, MBX_CHECK_INSTANT_MSG);
8131 } while(E_MBX_SUCCESS != result);
8132
8133 u8Index = tee_to_ree_mbx_msg.u8Index;
8134 DBG_AUDIO("Recv TEE Ack Msg OK cmd:%x\n", u8Index);
8135
8136 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL == u8Index)
8137 {
8138 DBG_AUDIO_ERROR("RecvMsg TEE_TO_REE_MBX_MSG_ACK_FAIL..\n");
8139 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8140 }
8141 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS == u8Index)
8142 {
8143 DBG_AUDIO("RecvMsg TEE_TO_REE_MBX_MSG_ACK_SUCCESS..\n");
8144 }
8145
8146 return TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
8147 }
8148 #else
_MAD_Proc(void)8149 static void _MAD_Proc(void)
8150 {
8151 MS_U32 u32Events;
8152 MS_U8 u8Index = 0;
8153 MBX_Result result;
8154
8155 DBG_AUDIO("_MAD_Proc...........\n");
8156
8157 while (1)
8158 {
8159 MsOS_WaitEvent(_s32MadEventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
8160 u8Index = msg.u8Index;
8161
8162 memset(&TeeToReeMbxAckMsg, 0, sizeof(MBX_Msg));
8163 TEE_TO_REE_MBX_MSG_INIT(TeeToReeMbxAckMsg);
8164 MBX_MSG_SET_CLASSID(TeeToReeMbxAckMsg, msg.u8MsgClass);
8165 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS);
8166
8167 switch ( u8Index )
8168 {
8169 case REE_TO_TEE_MBX_MSG_HAL_AUDSP_DspLoadCode:
8170 {
8171 if (HAL_AUDSP_DspLoadCode(msg.u8Parameters[0]) == FALSE)
8172 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8173
8174 break;
8175 }
8176
8177 case REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr:
8178 {
8179 MS_U32 u32Bin_Base_Address, u32Mad_Base_Buffer_Adr;
8180 u32Bin_Base_Address = (((MS_U32)(msg.u8Parameters[1])) | ((MS_U32)(msg.u8Parameters[2]) << 8) | ((MS_U32)(msg.u8Parameters[3]) << 16) | ((MS_U32)(msg.u8Parameters[4]) << 24));
8181 u32Mad_Base_Buffer_Adr = (((MS_U32)(msg.u8Parameters[5])) | ((MS_U32)(msg.u8Parameters[6]) << 8) | ((MS_U32)(msg.u8Parameters[7]) << 16) | ((MS_U32)(msg.u8Parameters[8]) << 24));
8182 HAL_AUDIO_SetDspBaseAddr(msg.u8Parameters[0], u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
8183 break;
8184 }
8185
8186 default:
8187 {
8188 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8189 break;
8190 }
8191 }
8192
8193 result = MApi_MBX_SendMsg(&TeeToReeMbxAckMsg);
8194 if (E_MBX_SUCCESS != result)
8195 DBG_AUDIO("MAD Reply Ack fail classid: %x cmd:%x \n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8196 else
8197 DBG_AUDIO("MAD Reply Ack ok classid:%x cmd:%x\n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8198 }
8199 }
8200
HAL_AUDIO_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)8201 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
8202 {
8203 if(pMsg==NULL)
8204 {
8205 DBG_AUDIO("pMsg is a null pointer\n");
8206 return;
8207 }
8208 if (_s32MadEventId < 0)
8209 {
8210 DBG_AUDIO("MAD EventGroup Id is not valid...\n");
8211 return;
8212 }
8213 memcpy(&msg, pMsg, sizeof(MBX_Msg));
8214 MsOS_SetEvent(_s32MadEventId, 1);
8215 return;
8216 }
8217 #endif
8218
8219 ////////////////////////////////////////////////////////////////////////////////
8220 /// @brief \b Function \b Name: HAL_AUDIO_update_DspUsage()
8221 /// @brief \b Function \b Description: update DSP resource status when select input source
8222 /// @param <IN> \b AUDIO_SOURCE_INFO_TYPE : select input source type
8223 /// @param <OUT> \b NONE :
8224 /// @param <RET> \b NONE :
8225 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)8226 void HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)
8227 {
8228 HALAUDIO_CHECK_SHM_INIT;
8229
8230 /* same input source, not update */
8231 if ( g_AudioVars2->eMainSourceType == eSourceType )
8232 {
8233 return;
8234 }
8235
8236 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
8237
8238 HALAUDIO_PRINT ("%s: PrevSource %d NowSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType, eSourceType);
8239
8240 /* release prev DSP resource */
8241 if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN && eSourceType != E_AUDIO_INFO_DTV_IN) )
8242 {
8243 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = FALSE;
8244 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8245 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_NONE;
8246 HALAUDIO_PRINT ("%s: Release DEC DSP from DTV !!\r\n", __FUNCTION__);
8247 }
8248 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN && eSourceType != E_AUDIO_INFO_ATV_IN) )
8249 {
8250 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8251 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8252 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8253 HALAUDIO_PRINT ("%s: Release SND DSP from ATV !!\r\n", __FUNCTION__);
8254 }
8255 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN && eSourceType != E_AUDIO_INFO_HDMI_IN) )
8256 {
8257 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8258 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8259 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8260 HALAUDIO_PRINT ("%s: Release SND DSP from HDMI !!\r\n", __FUNCTION__);
8261 }
8262
8263 g_AudioVars2->ePrevSourceType = g_AudioVars2->eMainSourceType;
8264 g_AudioVars2->eMainSourceType = eSourceType;
8265
8266 /* lock main input source DSP resource */
8267 if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN )
8268 {
8269 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = TRUE;
8270 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8271 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_DTV;
8272 HALAUDIO_PRINT ("%s: Alloc DEC DSP for DTV !!\r\n", __FUNCTION__);
8273 }
8274 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN )
8275 {
8276 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8277 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8278 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_ATV;
8279 HALAUDIO_PRINT ("%s: Alloc DEC DSP for ATV !!\r\n", __FUNCTION__);
8280 }
8281 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN )
8282 {
8283 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8284 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8285 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_HDMI;
8286 HALAUDIO_PRINT ("%s: Alloc DEC DSP for HDMI !!\r\n", __FUNCTION__);
8287 }
8288
8289 HALAUDIO_PRINT ("%s: update PrevSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType);
8290
8291 OS_RELEASE_MUTEX(_s32MutexLoadCode);
8292 }
8293
HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id)8294 Audio_id HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id) //temp
8295 {
8296 Audio_id ADEC_id;
8297 switch(dec_id)
8298 {
8299 case AU_DEC_INVALID:
8300 case AU_DEC_MAX:
8301 printf("[Error] Can't convert...\n");
8302 ADEC_id = ADEC1; //no usage just take one for it...
8303 break;
8304
8305 case AU_DEC_ID1:
8306 ADEC_id = ADEC1;
8307 break;
8308
8309 case AU_DEC_ID2:
8310 case AU_DEC_ID3:
8311 ADEC_id = ADEC2;
8312 break;
8313
8314 default:
8315 ADEC_id = ADEC1;
8316 break;
8317 }
8318 return ADEC_id;
8319 }
8320
8321 ////////////////////////////////////////////////////////////////////////////////
8322 /// @brief \b Function \b Name: HAL_AUDIO_GetCaps()
8323 /// @brief \b Function \b Description: Get Audio Capabilities
8324 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
8325 /// @param <IN> \b MS_U32 * : Audio Capabilites pointer
8326 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
8327 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId,MS_U32 * pCaps)8328 MS_U32 HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId, MS_U32 *pCaps)
8329 {
8330 AUDIO_CAPABILITIES *pCapsTmp = NULL;
8331 MS_U32 u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
8332
8333 HALAUDIO_CHECK_SHM_INIT;
8334
8335 if (pCaps == NULL)
8336 {
8337 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pCaps should not be NULL!\n", __FUNCTION__);
8338 return FALSE;
8339 }
8340
8341 if ((DecId <= AU_DEC_INVALID) || (DecId >= AU_DEC_MAX) || (DecId == AU_DEC_ID2))
8342 {
8343 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid DecId (%d)!\n", __FUNCTION__, DecId);
8344 return FALSE;
8345 }
8346 else if ((g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum == 1) && (DecId > AU_DEC_ID1))
8347 {
8348 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! DecId (%d) is greater than max decoder number (%d)!\n", __FUNCTION__, DecId, g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum);
8349 return FALSE;
8350 }
8351
8352 pCapsTmp = (AUDIO_CAPABILITIES *)pCaps;
8353
8354 if (pCapsTmp->u32AudioCapsVersion == 0)
8355 {
8356 #if defined (CONFIG_UTOPIA_ANDROID_L)
8357 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsVersion);
8358 #else
8359 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion);
8360 #endif
8361 return FALSE;
8362 }
8363
8364 if (pCapsTmp->u32AudioCapsStructSize == 0)
8365 {
8366 #if defined (CONFIG_UTOPIA_ANDROID_L)
8367 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsStructSize);
8368 #else
8369 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsStructSize);
8370 #endif
8371 return FALSE;
8372 }
8373
8374 if (pCapsTmp->u32AudioCapsVersion != g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion)
8375 {
8376 #if defined (CONFIG_UTOPIA_ANDROID_L)
8377 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! function caller's version (%u) is not matched to driver's version (%u) at DecId (%d)\n", __FUNCTION__, pCapsTmp->u32AudioCapsVersion, g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion, DecId);
8378 #else
8379 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! function caller's version (%u) is not matched to driver's version (%u) at DecId (%d)\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion, (unsigned int)g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion, DecId);
8380 #endif
8381
8382 u32AudioCapsStructSize = (u32AudioCapsStructSize <= pCapsTmp->u32AudioCapsStructSize) ? u32AudioCapsStructSize : pCapsTmp->u32AudioCapsStructSize;
8383 }
8384
8385 memcpy((void *)pCapsTmp, (void *)&g_AudioVars2->AudioCaps[DecId], u32AudioCapsStructSize);
8386
8387 return TRUE;
8388 }
8389
HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue,MS_U32 * pData)8390 MS_S32 HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue, MS_U32 *pData)
8391 {
8392 return 0;
8393 }
8394
HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue,MS_U32 * pData,MS_U32 u32Count)8395 MS_S32 HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue, MS_U32 *pData, MS_U32 u32Count)
8396 {
8397 MS_U32 u32Loop = 0;
8398 MS_S32 s32Ret = -A_EINVAL;
8399
8400 if (u32Count == 0)
8401 {
8402 return -A_EINVAL;
8403 }
8404
8405 if (pData != NULL)
8406 {
8407 for (u32Loop = 0; u32Loop < u32Count ; u32Loop++)
8408 {
8409 if (pData[u32Loop] == 0)
8410 {
8411 break;
8412 }
8413
8414 if (u32alue == pData[u32Loop])
8415 {
8416 s32Ret = 0;
8417 break;
8418 }
8419 }
8420 }
8421 else
8422 {
8423 s32Ret = -A_EFAULT;
8424 }
8425
8426 return s32Ret;
8427 }
8428
8429 #if AUDIO_HW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)8430 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)
8431 {
8432 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8433 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8434 MS_U16 u16Divisor = 0;
8435 MS_U16 u16Synthrate = 0;
8436 MS_U32 u32TargetBufferSize = 0;
8437 MS_U32 u32TargetChannel = 0;
8438 MS_U32 u32TargetBitWidth = 0;
8439 MS_U32 u32TargetAlignmentSize = 0;
8440 MS_S32 s32Ret = 0;
8441
8442 /*
8443 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
8444 */
8445 switch(pPcmInfo->u32SampleRate) {
8446 case 8000:
8447 {
8448 u16Divisor = 2;
8449 u16Synthrate = 0x6978;
8450 break;
8451 }
8452
8453 case 11025:
8454 {
8455 u16Divisor = 2;
8456 u16Synthrate = 0x4C87;
8457 break;
8458 }
8459
8460 case 12000:
8461 {
8462 u16Divisor = 2;
8463 u16Synthrate = 0x4650;
8464 break;
8465 }
8466
8467 case 16000:
8468 {
8469 u16Divisor = 1;
8470 u16Synthrate = 0x6978;
8471 break;
8472 }
8473
8474 case 22050:
8475 {
8476 u16Divisor = 1;
8477 u16Synthrate = 0x4C87;
8478 break;
8479 }
8480
8481 case 24000:
8482 {
8483 u16Divisor = 1;
8484 u16Synthrate = 0x4650;
8485 break;
8486 }
8487
8488 case 32000:
8489 {
8490 u16Divisor = 0;
8491 u16Synthrate = 0x6978;
8492 break;
8493 }
8494
8495 case 44100:
8496 {
8497 u16Divisor = 0;
8498 u16Synthrate = 0x4C87;
8499 break;
8500 }
8501
8502 case 48000:
8503 {
8504 u16Divisor = 0;
8505 u16Synthrate = 0x4650;
8506 break;
8507 }
8508
8509 case 96000:
8510 {
8511 u16Divisor = 0;
8512 u16Synthrate = 0x2328;
8513 break;
8514 }
8515
8516 default:
8517 {
8518 u16Divisor = 0;
8519 u16Synthrate = 0x4650;
8520 pPcmInfo->u32SampleRate = 48000;
8521 break;
8522 }
8523 }
8524
8525 /* enable DMA synthesizer */
8526 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG0, 0x20, 0x20);
8527
8528 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
8529 HAL_AUDIO_WriteMaskReg(REG_AUDIO_CLK_CFG6, 0x6000, (u16Divisor << 13));
8530 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_SYNTH_NF, 0xFFFF, u16Synthrate);
8531
8532 /* calculate buffer size */
8533 u32TargetChannel = 2;
8534 u32TargetBitWidth = 16;
8535 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
8536 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
8537 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
8538 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
8539 {
8540 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate);
8541 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
8542 pPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
8543 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
8544 }
8545
8546 /* set buffer size */
8547 u32TargetBufferSize = u32TargetBufferSize * 2; /* for HW DMA Reader specification */
8548 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_3, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
8549
8550 /* set overrun & underrun threshold */
8551 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_4, 0xFFFF, u32TargetBufferSize - 12);
8552 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_5, 0xFFFF, 0x0012);
8553
8554 pPCM->u8SettingChangeFlag = FALSE;
8555
8556 return s32Ret;
8557 }
8558
HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)8559 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)
8560 {
8561 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8562 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8563 MS_S32 s32Ret = 0;
8564
8565 if (pPcmInfo->u8ConnectFlag == FALSE)
8566 {
8567 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
8568 return -A_EPERM;
8569 }
8570
8571 /* clear PCM buffer */
8572 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
8573
8574 /* flush MIU */
8575 MsOS_FlushMemory();
8576
8577 /* clear engine's write pointer */
8578 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, 0x0000);
8579
8580 /* reset & start engine */
8581 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x6402);
8582 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x2402);
8583
8584 /* reset write pointer */
8585 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
8586
8587 /* reset remain size */
8588 pPCM->tPcmBufferInfo.u32RemainSize = 0;
8589
8590 return s32Ret;
8591 }
8592
HAL_AUDIO_PCM_HwDma_Reader1_Open(void * pData)8593 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Open(void *pData)
8594 {
8595 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8596 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8597 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
8598 MS_U32 u32TargetBufferAddrPa = 0;
8599 MS_U32 u32TargetBufferSize = 0;
8600 MS_U32 u32TargetChannel = 0;
8601 MS_U32 u32TargetBitWidth = 0;
8602 MS_U32 u32TargetAlignmentSize = 0;
8603 MS_S32 s32Ret = 0;
8604 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
8605
8606 if (pData == NULL)
8607 {
8608 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
8609 return -A_EFAULT;
8610 }
8611
8612 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
8613
8614 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
8615 {
8616 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
8617 return -A_EINVAL;
8618 }
8619
8620 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
8621 {
8622 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
8623 return -A_EINVAL;
8624 }
8625
8626 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8627 {
8628 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8629 return -A_EINVAL;
8630 }
8631
8632 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8633 {
8634 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
8635 return -A_EINVAL;
8636 }
8637
8638 if (pUserPcmInfo->u8CaptureFlag == TRUE)
8639 {
8640 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
8641 return -A_EINVAL;
8642 }
8643
8644 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
8645 {
8646 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
8647 return -A_EINVAL;
8648 }
8649
8650 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
8651 {
8652 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
8653 return -A_EINVAL;
8654 }
8655
8656 /* calculate buffer size */
8657 u32TargetChannel = 2;
8658 u32TargetBitWidth = 16;
8659 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
8660 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
8661 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
8662 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
8663 {
8664 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate);
8665 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
8666 pUserPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
8667 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
8668 }
8669
8670 /* fill in settings */
8671 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8672 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
8673 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
8674 pPcmInfo->u8ConnectFlag = TRUE;
8675 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
8676 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
8677 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
8678 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
8679 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
8680 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
8681 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
8682 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
8683 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
8684 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
8685 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
8686 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
8687
8688 /* init PCM buffer address */
8689 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR;
8690 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
8691 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
8692 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
8693
8694 /* set PCM buffer address */
8695 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DMA_RD_CTRL_7, 0xFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFF)); /* RD_BASE_ADDR[7:0] */
8696 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_2, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 8) & 0xFFFF)); /* RD_BASE_ADDR[23:8] */
8697 HAL_AUDIO_WriteMaskByte((REG_AUDIO_DMA_RD_CTRL_7 + 1), 0x0F, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 24) & 0x0F)); /* RD_BASE_ADDR[27:24] */
8698
8699 /* set SEL_CLK_DMA_READER */
8700 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG6, 0x07, 0x04);
8701
8702 /* apply setting */
8703 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
8704
8705 /* restart */
8706 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
8707
8708 /* TODO : force channel8 to HW DMA Reader1, it's a hardcode */
8709 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04);
8710 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F);
8711
8712 return s32Ret;
8713 }
8714
HAL_AUDIO_PCM_HwDma_Reader1_Close(void)8715 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Close(void)
8716 {
8717 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8718 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8719 MS_S32 s32Ret = 0;
8720 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
8721
8722 if (pPcmInfo->u8ConnectFlag != FALSE)
8723 {
8724 HAL_AUDIO_PCM_HwDma_Reader1_Flush();
8725 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8726 }
8727
8728 return s32Ret;
8729 }
8730
HAL_AUDIO_PCM_HwDma_Reader1_Start(void)8731 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Start(void)
8732 {
8733 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8734 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8735 MS_S32 s32Ret = 0;
8736 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
8737
8738 if (pPcmInfo->u8StartFlag == FALSE)
8739 {
8740 if (pPCM->u8SettingChangeFlag == TRUE)
8741 {
8742 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
8743 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
8744 }
8745
8746 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0001);
8747 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0100);
8748
8749 pPcmInfo->u8StartFlag = TRUE;
8750 }
8751
8752 return s32Ret;
8753 }
8754
HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)8755 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)
8756 {
8757 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8758 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8759 MS_S32 s32Ret = 0;
8760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
8761
8762 if (pPcmInfo->u8StartFlag != FALSE)
8763 {
8764 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0000);
8765 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0000);
8766
8767 pPcmInfo->u8StartFlag = FALSE;
8768 }
8769
8770 return s32Ret;
8771 }
8772
HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)8773 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
8774 {
8775 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8776 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8777 MS_S32 s32Ret = 0;
8778 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
8779
8780 if (pData == NULL)
8781 {
8782 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
8783 return -A_EFAULT;
8784 }
8785
8786 if (pPcmInfo->u8ConnectFlag == FALSE)
8787 {
8788 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
8789 return -A_EPERM;
8790 }
8791
8792 switch(u32Cmd)
8793 {
8794 case AUDIO_PCM_CMD_NONBLOCKING:
8795 {
8796 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
8797
8798 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
8799 {
8800 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
8801 s32Ret = -A_EINVAL;
8802 break;
8803 }
8804
8805 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
8806
8807 break;
8808 }
8809
8810 case AUDIO_PCM_CMD_MULTICH:
8811 {
8812 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
8813
8814 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
8815 {
8816 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
8817 s32Ret = -A_EINVAL;
8818 break;
8819 }
8820
8821 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8822 {
8823 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8824 s32Ret = -A_EINVAL;
8825 break;
8826 }
8827
8828 pPcmInfo->u8MultiChFlag = FALSE;
8829
8830 break;
8831 }
8832
8833 case AUDIO_PCM_CMD_MIXING:
8834 {
8835 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
8836
8837 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
8838 {
8839 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
8840 s32Ret = -A_EINVAL;
8841 break;
8842 }
8843
8844 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8845 {
8846 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
8847 s32Ret = -A_EINVAL;
8848 break;
8849 }
8850
8851 pPcmInfo->u8MixingFlag = FALSE;
8852
8853 break;
8854 }
8855
8856 case AUDIO_PCM_CMD_MIXINGGROUP:
8857 {
8858 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
8859
8860 pPcmInfo->u32MixingGroup = u32MixingGroup;
8861
8862 break;
8863 }
8864
8865 case AUDIO_PCM_CMD_BUFFERDURATION:
8866 {
8867 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
8868
8869 if (u32BufferDuration == 0)
8870 {
8871 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
8872 s32Ret = -A_EINVAL;
8873 break;
8874 }
8875
8876 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
8877 {
8878 pPcmInfo->u32BufferDuration = u32BufferDuration;
8879 pPCM->u8SettingChangeFlag = TRUE;
8880 }
8881
8882 break;
8883 }
8884
8885 case AUDIO_PCM_CMD_CHANNEL:
8886 {
8887 MS_U32 u32Channel = *((MS_U32 *)pData);
8888
8889 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
8890 {
8891 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
8892 return -A_EINVAL;
8893 }
8894
8895 pPcmInfo->u32Channel = u32Channel;
8896
8897 break;
8898 }
8899
8900 case AUDIO_PCM_CMD_SAMPLERATE:
8901 {
8902 MS_U32 u32SampleRate = *((MS_U32 *)pData);
8903
8904 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
8905 {
8906 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
8907 return -A_EINVAL;
8908 }
8909
8910 if (pPcmInfo->u32SampleRate != u32SampleRate)
8911 {
8912 pPcmInfo->u32SampleRate = u32SampleRate;
8913 pPCM->u8SettingChangeFlag = TRUE;
8914 }
8915
8916 break;
8917 }
8918
8919 case AUDIO_PCM_CMD_BITWIDTH:
8920 {
8921 MS_U32 u32BitWidth = *((MS_U32 *)pData);
8922
8923 pPcmInfo->u32BitWidth = u32BitWidth;
8924
8925 break;
8926 }
8927
8928 case AUDIO_PCM_CMD_BIGENDIAN:
8929 {
8930 MS_U32 u32BigEndian = *((MS_U32 *)pData);
8931
8932 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
8933 {
8934 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
8935 return -A_EINVAL;
8936 }
8937
8938 pPcmInfo->u32BigEndian = u32BigEndian;
8939
8940 break;
8941 }
8942
8943 case AUDIO_PCM_CMD_TIMESTAMP:
8944 {
8945 MS_U32 u32Timestamp = *((MS_U32 *)pData);
8946
8947 pPcmInfo->u32Timestamp = u32Timestamp;
8948
8949 break;
8950 }
8951
8952 case AUDIO_PCM_CMD_WEIGHTING:
8953 {
8954 MS_U32 u32Weighting = *((MS_U32 *)pData);
8955
8956 if (u32Weighting > 100)
8957 {
8958 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
8959 return -A_EINVAL;
8960 }
8961
8962 pPcmInfo->u32Weighting = u32Weighting;
8963
8964 break;
8965 }
8966
8967 case AUDIO_PCM_CMD_VOLUME:
8968 {
8969 MS_U32 u32Volume = *((MS_U32 *)pData);
8970
8971 if (u32Volume > 100)
8972 {
8973 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
8974 return -A_EINVAL;
8975 }
8976
8977 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
8978
8979 break;
8980 }
8981
8982 case AUDIO_PCM_CMD_MUTE:
8983 {
8984 MS_U32 u32Mute = *((MS_U32*)pData);
8985
8986 if (u32Mute == TRUE)
8987 {
8988 pPcmInfo->u32Volume |= 0x80000000;
8989 }
8990 else if (u32Mute == FALSE)
8991 {
8992 pPcmInfo->u32Volume &= 0x7FFFFFFF;
8993 }
8994 else
8995 {
8996 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
8997 s32Ret = -A_EINVAL;
8998 }
8999 break;
9000 }
9001
9002 default:
9003 {
9004 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9005 break;
9006 }
9007 }
9008
9009 return s32Ret;
9010 }
9011
HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)9012 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
9013 {
9014 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9015 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9016 MS_S32 s32Ret = 0;
9017 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9018
9019 if (pData == NULL)
9020 {
9021 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9022 return -A_EFAULT;
9023 }
9024
9025 if (pPcmInfo->u8ConnectFlag == FALSE)
9026 {
9027 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9028 return -A_EPERM;
9029 }
9030
9031 switch(u32Cmd)
9032 {
9033 case AUDIO_PCM_CMD_ALL:
9034 {
9035 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9036 MS_U32 u32MinSize = 0;
9037
9038 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9039 {
9040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9041 s32Ret = -A_EINVAL;
9042 break;
9043 }
9044 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
9045 {
9046 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9047 }
9048
9049 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
9050 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
9051 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
9052
9053 break;
9054 }
9055
9056 case AUDIO_PCM_CMD_NONBLOCKING:
9057 {
9058 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9059 break;
9060 }
9061
9062 case AUDIO_PCM_CMD_MULTICH:
9063 {
9064 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9065 break;
9066 }
9067
9068 case AUDIO_PCM_CMD_MIXING:
9069 {
9070 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9071 break;
9072 }
9073
9074 case AUDIO_PCM_CMD_MIXINGGROUP:
9075 {
9076 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9077 break;
9078 }
9079
9080 case AUDIO_PCM_CMD_BUFFER:
9081 {
9082 /*
9083 * TODO, need better coding
9084 *
9085 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
9086 */
9087 break;
9088 }
9089
9090 case AUDIO_PCM_CMD_BUFFERDURATION:
9091 {
9092 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9093 break;
9094 }
9095
9096 case AUDIO_PCM_CMD_READPTR:
9097 {
9098 /*
9099 * TODO, need better coding
9100 *
9101 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
9102 */
9103 break;
9104 }
9105
9106 case AUDIO_PCM_CMD_WRITEPTR:
9107 {
9108 /*
9109 * TODO, need better coding
9110 *
9111 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
9112 */
9113 break;
9114 }
9115
9116 case AUDIO_PCM_CMD_CHANNEL:
9117 {
9118 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9119 break;
9120 }
9121
9122 case AUDIO_PCM_CMD_SAMPLERATE:
9123 {
9124 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9125 break;
9126 }
9127
9128 case AUDIO_PCM_CMD_BITWIDTH:
9129 {
9130 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
9131 break;
9132 }
9133
9134 case AUDIO_PCM_CMD_BIGENDIAN:
9135 {
9136 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
9137 break;
9138 }
9139
9140 case AUDIO_PCM_CMD_TIMESTAMP:
9141 {
9142 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
9143 break;
9144 }
9145
9146 case AUDIO_PCM_CMD_WEIGHTING:
9147 {
9148 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
9149 break;
9150 }
9151
9152 case AUDIO_PCM_CMD_VOLUME:
9153 {
9154 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
9155 break;
9156 }
9157
9158 case AUDIO_PCM_CMD_BUFFERLEVEL:
9159 {
9160 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0010);
9161 pPcmInfo->u32BufferLevel = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_6) * BYTES_IN_MIU_LINE) / 2;
9162 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0000);
9163 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
9164 break;
9165 }
9166
9167 case AUDIO_PCM_CMD_MUTE:
9168 {
9169 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
9170 break;
9171 }
9172
9173 case AUDIO_PCM_CMD_BUFFERSIZE:
9174 {
9175 *((MS_U32 *)pData) = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_3) * BYTES_IN_MIU_LINE) / 2; /* return valid size */
9176 break;
9177 }
9178
9179 default:
9180 {
9181 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9182 break;
9183 }
9184 }
9185
9186 return s32Ret;
9187 }
9188
HAL_AUDIO_PCM_HwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)9189 MS_U32 HAL_AUDIO_PCM_HwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
9190 {
9191 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9192 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9193 MS_S8 *pBufTmp = NULL;
9194 MS_U32 u32BufferSize = 0;
9195 MS_U32 u32PcmLevel = 0;
9196 MS_U32 u32RequestSize = 0;
9197 MS_U32 u32RequestSampleCount = 0;
9198 MS_U32 u32Loop = 0;
9199 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
9200
9201 if (pBuf == NULL)
9202 {
9203 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
9204 return 0;
9205 }
9206
9207 if (u32Size == 0)
9208 {
9209 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
9210 return 0;
9211 }
9212
9213 if (pPcmInfo->u8ConnectFlag == FALSE)
9214 {
9215 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9216 return 0;
9217 }
9218
9219 if (pPcmInfo->u8StartFlag == FALSE)
9220 {
9221 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
9222 return 0;
9223 }
9224
9225 pBufTmp = (MS_S8 *)pBuf;
9226
9227 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
9228 u32PcmLevel = u32PcmLevel * 2;
9229 if ((u32PcmLevel / BYTES_IN_MIU_LINE) <= 6)
9230 {
9231 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
9232
9233 u32PcmLevel = 0;
9234 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9235 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9236 HAL_AUDIO_PCM_HwDma_Reader1_Start();
9237 }
9238
9239 u32RequestSize = u32Size * 2;
9240 u32RequestSampleCount = u32Size / 2;
9241
9242 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
9243 u32BufferSize = u32BufferSize * 2;
9244
9245 /* copy data to PCM buffer */
9246 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
9247 {
9248 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
9249 {
9250 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9251 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L low, R low, L low, R low, ... */
9252 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L high, R high, L high, R high, ... */
9253 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9254
9255 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9256 {
9257 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9258 {
9259 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
9260 }
9261 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9262 }
9263 }
9264
9265 /* flush MIU */
9266 MsOS_FlushMemory();
9267
9268 /* update copied size to engine */
9269 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
9270 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, (u32RequestSize/BYTES_IN_MIU_LINE));
9271 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
9272 #ifdef MSOS_TYPE_LINUX_KERNEL
9273 udelay(50);
9274 #else
9275 AUDIO_DELAY1US(50);
9276 #endif
9277
9278 return u32Size;
9279 }
9280
9281 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
9282
9283 return 0;
9284 }
9285
HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)9286 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)
9287 {
9288 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9289 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9290 MS_S32 s32Ret = 0;
9291 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
9292
9293 if (pPcmInfo->u8StartFlag == FALSE)
9294 {
9295 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9296 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9297 }
9298
9299 return s32Ret;
9300 }
9301 #endif
9302
9303 #if AUDIO_HW_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)9304 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)
9305 {
9306 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9307 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9308 MS_U16 u16Divisor = 0;
9309 MS_U16 u16Synthrate = 0;
9310 MS_U32 u32TargetBufferSize = 0;
9311 MS_U32 u32TargetChannel = 0;
9312 MS_U32 u32TargetBitWidth = 0;
9313 MS_U32 u32TargetAlignmentSize = 0;
9314 MS_S32 s32Ret = 0;
9315
9316 /*
9317 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
9318 */
9319 switch(pPcmInfo->u32SampleRate) {
9320 case 8000:
9321 {
9322 u16Divisor = 2;
9323 u16Synthrate = 0x6978;
9324 break;
9325 }
9326
9327 case 11025:
9328 {
9329 u16Divisor = 2;
9330 u16Synthrate = 0x4C87;
9331 break;
9332 }
9333
9334 case 12000:
9335 {
9336 u16Divisor = 2;
9337 u16Synthrate = 0x4650;
9338 break;
9339 }
9340
9341 case 16000:
9342 {
9343 u16Divisor = 1;
9344 u16Synthrate = 0x6978;
9345 break;
9346 }
9347
9348 case 22050:
9349 {
9350 u16Divisor = 1;
9351 u16Synthrate = 0x4C87;
9352 break;
9353 }
9354
9355 case 24000:
9356 {
9357 u16Divisor = 1;
9358 u16Synthrate = 0x4650;
9359 break;
9360 }
9361
9362 case 32000:
9363 {
9364 u16Divisor = 0;
9365 u16Synthrate = 0x6978;
9366 break;
9367 }
9368
9369 case 44100:
9370 {
9371 u16Divisor = 0;
9372 u16Synthrate = 0x4C87;
9373 break;
9374 }
9375
9376 case 48000:
9377 {
9378 u16Divisor = 0;
9379 u16Synthrate = 0x4650;
9380 break;
9381 }
9382
9383 default:
9384 {
9385 u16Divisor = 0;
9386 u16Synthrate = 0x4650;
9387 pPcmInfo->u32SampleRate = 48000;
9388 break;
9389 }
9390 }
9391
9392 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9393 HAL_AUDIO_AbsWriteReg(NewDMAreader_ctrl, 0x0000);
9394 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0030, (u16Divisor << 4));
9395 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Syth, 0xFFFF, u16Synthrate);
9396
9397 /* enable DMA synthesizer */
9398 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0145, 0x0145);
9399
9400 /* calculate buffer size */
9401 u32TargetChannel = 2;
9402 u32TargetBitWidth = 16;
9403 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9404 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9405 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9406 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9407 {
9408 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pPcmInfo->u32BufferDuration, (unsigned int)pPcmInfo->u32SampleRate);
9409 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9410 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
9411 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
9412 }
9413
9414 /* set buffer size */
9415 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9416
9417 /* set overrun & underrun threshold */
9418 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x0012);
9419
9420 pPCM->u8SettingChangeFlag = FALSE;
9421
9422 return s32Ret;
9423 }
9424
HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)9425 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)
9426 {
9427 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9428 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9429 MS_S32 s32Ret = 0;
9430
9431 if (pPcmInfo->u8ConnectFlag == FALSE)
9432 {
9433 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9434 return -A_EPERM;
9435 }
9436
9437 /* clear PCM buffer */
9438 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR2_BUF_SIZE);
9439
9440 /* flush MIU */
9441 MsOS_FlushMemory();
9442
9443 /* clear engine's write pointer */
9444 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, 0x0000);
9445
9446 /* reset & start engine */
9447 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
9448 #ifdef MSOS_TYPE_LINUX_KERNEL
9449 udelay(50);
9450 #else
9451 AUDIO_DELAY1US(50);
9452 #endif
9453 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
9454
9455 /* reset write pointer */
9456 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9457
9458 /* reset remain size */
9459 pPCM->tPcmBufferInfo.u32RemainSize = 0;
9460
9461 return s32Ret;
9462 }
9463
HAL_AUDIO_PCM_HwDma_Reader2_Open(void * pData)9464 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Open(void *pData)
9465 {
9466 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9467 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9468 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
9469 MS_U32 u32TargetBufferAddrPa = 0;
9470 MS_U32 u32TargetBufferSize = 0;
9471 MS_U32 u32TargetChannel = 0;
9472 MS_U32 u32TargetBitWidth = 0;
9473 MS_U32 u32TargetAlignmentSize = 0;
9474 MS_S32 s32Ret = 0;
9475 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
9476
9477 if (pData == NULL)
9478 {
9479 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9480 return -A_EFAULT;
9481 }
9482
9483 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9484
9485 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9486 {
9487 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9488 return -A_EINVAL;
9489 }
9490
9491 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9492 {
9493 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
9494 return -A_EINVAL;
9495 }
9496
9497 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9498 {
9499 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9500 return -A_EINVAL;
9501 }
9502
9503 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9504 {
9505 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9506 return -A_EINVAL;
9507 }
9508
9509 if (pUserPcmInfo->u8CaptureFlag == TRUE)
9510 {
9511 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
9512 return -A_EINVAL;
9513 }
9514
9515 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9516 {
9517 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
9518 return -A_EINVAL;
9519 }
9520
9521 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9522 {
9523 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
9524 return -A_EINVAL;
9525 }
9526
9527 /* calculate buffer size */
9528 u32TargetChannel = 2;
9529 u32TargetBitWidth = 16;
9530 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9531 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9532 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9533 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9534 {
9535 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pUserPcmInfo->u32BufferDuration, (unsigned int)pUserPcmInfo->u32SampleRate);
9536 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9537 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
9538 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
9539 }
9540
9541 /* fill in settings */
9542 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9543 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
9544 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
9545 pPcmInfo->u8ConnectFlag = TRUE;
9546 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9547 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9548
9549 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
9550 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
9551 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
9552 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
9553 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
9554 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
9555 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
9556 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
9557 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
9558 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
9559
9560 /* init PCM buffer address */
9561 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR2_BUF_ADDR;
9562 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
9563 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
9564 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9565
9566 /* set PCM buffer address */
9567 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Lo, 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* RD_BASE_ADDR[15:0] */
9568 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Hi, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16) & 0xFFFF)); /* RD_BASE_ADDR[31:15] */
9569
9570 /* apply setting */
9571 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
9572
9573 /* restart */
9574 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
9575
9576 /* TODO : force channel6 to HW DMA Reader2, it's a hardcode */
9577 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x90);
9578
9579 return s32Ret;
9580 }
9581
HAL_AUDIO_PCM_HwDma_Reader2_Close(void)9582 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Close(void)
9583 {
9584 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9585 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9586 MS_S32 s32Ret = 0;
9587 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
9588
9589 if (pPcmInfo->u8ConnectFlag != FALSE)
9590 {
9591 HAL_AUDIO_PCM_HwDma_Reader2_Flush();
9592 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9593 }
9594
9595 return s32Ret;
9596 }
9597
HAL_AUDIO_PCM_HwDma_Reader2_Start(void)9598 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Start(void)
9599 {
9600 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9601 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9602 MS_S32 s32Ret = 0;
9603 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
9604
9605 if (pPcmInfo->u8StartFlag == FALSE)
9606 {
9607 if (pPCM->u8SettingChangeFlag == TRUE)
9608 {
9609 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
9610 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
9611 }
9612
9613 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0001);
9614 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0002);
9615
9616 pPcmInfo->u8StartFlag = TRUE;
9617 }
9618
9619 return s32Ret;
9620 }
9621
HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)9622 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)
9623 {
9624 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9625 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9626 MS_S32 s32Ret = 0;
9627 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
9628
9629 if (pPcmInfo->u8StartFlag != FALSE)
9630 {
9631 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0000);
9632 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0000);
9633
9634 pPcmInfo->u8StartFlag = FALSE;
9635 }
9636
9637 return s32Ret;
9638 }
9639
HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd,const void * pData)9640 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
9641 {
9642 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9643 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9644 MS_S32 s32Ret = 0;
9645 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9646
9647 if (pData == NULL)
9648 {
9649 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9650 return -A_EFAULT;
9651 }
9652
9653 if (pPcmInfo->u8ConnectFlag == FALSE)
9654 {
9655 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9656 return -A_EPERM;
9657 }
9658
9659 switch(u32Cmd)
9660 {
9661 case AUDIO_PCM_CMD_NONBLOCKING:
9662 {
9663 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
9664
9665 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
9666 {
9667 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
9668 s32Ret = -A_EINVAL;
9669 break;
9670 }
9671
9672 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
9673
9674 break;
9675 }
9676
9677 case AUDIO_PCM_CMD_MULTICH:
9678 {
9679 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
9680
9681 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
9682 {
9683 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
9684 s32Ret = -A_EINVAL;
9685 break;
9686 }
9687
9688 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9689 {
9690 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9691 s32Ret = -A_EINVAL;
9692 break;
9693 }
9694
9695 pPcmInfo->u8MultiChFlag = FALSE;
9696
9697 break;
9698 }
9699
9700 case AUDIO_PCM_CMD_MIXING:
9701 {
9702 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
9703
9704 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
9705 {
9706 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
9707 s32Ret = -A_EINVAL;
9708 break;
9709 }
9710
9711 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9712 {
9713 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9714 s32Ret = -A_EINVAL;
9715 break;
9716 }
9717
9718 pPcmInfo->u8MixingFlag = FALSE;
9719
9720 break;
9721 }
9722
9723 case AUDIO_PCM_CMD_MIXINGGROUP:
9724 {
9725 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
9726
9727 pPcmInfo->u32MixingGroup = u32MixingGroup;
9728
9729 break;
9730 }
9731
9732 case AUDIO_PCM_CMD_BUFFERDURATION:
9733 {
9734 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
9735
9736 if (u32BufferDuration == 0)
9737 {
9738 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
9739 s32Ret = -A_EINVAL;
9740 break;
9741 }
9742
9743 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
9744 {
9745 pPcmInfo->u32BufferDuration = u32BufferDuration;
9746 pPCM->u8SettingChangeFlag = TRUE;
9747 }
9748
9749 break;
9750 }
9751
9752 case AUDIO_PCM_CMD_CHANNEL:
9753 {
9754 MS_U32 u32Channel = *((MS_U32 *)pData);
9755
9756 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9757 {
9758 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
9759 return -A_EINVAL;
9760 }
9761
9762 pPcmInfo->u32Channel = u32Channel;
9763
9764 break;
9765 }
9766
9767 case AUDIO_PCM_CMD_SAMPLERATE:
9768 {
9769 MS_U32 u32SampleRate = *((MS_U32 *)pData);
9770
9771 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9772 {
9773 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
9774 return -A_EINVAL;
9775 }
9776
9777 if (pPcmInfo->u32SampleRate != u32SampleRate)
9778 {
9779 pPcmInfo->u32SampleRate = u32SampleRate;
9780 pPCM->u8SettingChangeFlag = TRUE;
9781 }
9782
9783 break;
9784 }
9785
9786 case AUDIO_PCM_CMD_BITWIDTH:
9787 {
9788 MS_U32 u32BitWidth = *((MS_U32 *)pData);
9789
9790 pPcmInfo->u32BitWidth = u32BitWidth;
9791
9792 break;
9793 }
9794
9795 case AUDIO_PCM_CMD_BIGENDIAN:
9796 {
9797 MS_U32 u32BigEndian = *((MS_U32 *)pData);
9798
9799 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
9800 {
9801 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
9802 return -A_EINVAL;
9803 }
9804
9805 pPcmInfo->u32BigEndian = u32BigEndian;
9806
9807 break;
9808 }
9809
9810 case AUDIO_PCM_CMD_TIMESTAMP:
9811 {
9812 MS_U32 u32Timestamp = *((MS_U32 *)pData);
9813
9814 pPcmInfo->u32Timestamp = u32Timestamp;
9815
9816 break;
9817 }
9818
9819 case AUDIO_PCM_CMD_WEIGHTING:
9820 {
9821 MS_U32 u32Weighting = *((MS_U32 *)pData);
9822
9823 if (u32Weighting > 100)
9824 {
9825 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
9826 return -A_EINVAL;
9827 }
9828
9829 pPcmInfo->u32Weighting = u32Weighting;
9830
9831 break;
9832 }
9833
9834 case AUDIO_PCM_CMD_VOLUME:
9835 {
9836 MS_U32 u32Volume = *((MS_U32 *)pData);
9837
9838 if (u32Volume > 100)
9839 {
9840 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
9841 return -A_EINVAL;
9842 }
9843
9844 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
9845
9846 break;
9847 }
9848
9849 case AUDIO_PCM_CMD_MUTE:
9850 {
9851 MS_U32 u32Mute = *((MS_U32*)pData);
9852
9853 if (u32Mute == TRUE)
9854 {
9855 pPcmInfo->u32Volume |= 0x80000000;
9856 }
9857 else if (u32Mute == FALSE)
9858 {
9859 pPcmInfo->u32Volume &= 0x7FFFFFFF;
9860 }
9861 else
9862 {
9863 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
9864 s32Ret = -A_EINVAL;
9865 }
9866 break;
9867 }
9868
9869 default:
9870 {
9871 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
9872 break;
9873 }
9874 }
9875
9876 return s32Ret;
9877 }
9878
HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd,void * pData)9879 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd, void *pData)
9880 {
9881 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9882 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9883 MS_S32 s32Ret = 0;
9884 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9885
9886 if (pData == NULL)
9887 {
9888 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9889 return -A_EFAULT;
9890 }
9891
9892 if (pPcmInfo->u8ConnectFlag == FALSE)
9893 {
9894 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9895 return -A_EPERM;
9896 }
9897
9898 switch(u32Cmd)
9899 {
9900 case AUDIO_PCM_CMD_ALL:
9901 {
9902 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9903 MS_U32 u32MinSize = 0;
9904
9905 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9906 {
9907 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9908 s32Ret = -A_EINVAL;
9909 break;
9910 }
9911 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
9912 {
9913 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9914 }
9915
9916 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
9917 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
9918 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
9919
9920 break;
9921 }
9922
9923 case AUDIO_PCM_CMD_NONBLOCKING:
9924 {
9925 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9926 break;
9927 }
9928
9929 case AUDIO_PCM_CMD_MULTICH:
9930 {
9931 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9932 break;
9933 }
9934
9935 case AUDIO_PCM_CMD_MIXING:
9936 {
9937 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9938 break;
9939 }
9940
9941 case AUDIO_PCM_CMD_MIXINGGROUP:
9942 {
9943 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9944 break;
9945 }
9946
9947 case AUDIO_PCM_CMD_BUFFER:
9948 {
9949 /*
9950 * TODO, need better coding
9951 *
9952 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
9953 */
9954 break;
9955 }
9956
9957 case AUDIO_PCM_CMD_BUFFERDURATION:
9958 {
9959 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9960 break;
9961 }
9962
9963 case AUDIO_PCM_CMD_READPTR:
9964 {
9965 /*
9966 * TODO, need better coding
9967 *
9968 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
9969 */
9970 break;
9971 }
9972
9973 case AUDIO_PCM_CMD_WRITEPTR:
9974 {
9975 /*
9976 * TODO, need better coding
9977 *
9978 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
9979 */
9980 break;
9981 }
9982
9983 case AUDIO_PCM_CMD_CHANNEL:
9984 {
9985 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9986 break;
9987 }
9988
9989 case AUDIO_PCM_CMD_SAMPLERATE:
9990 {
9991 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9992 break;
9993 }
9994
9995 case AUDIO_PCM_CMD_BITWIDTH:
9996 {
9997 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
9998 break;
9999 }
10000
10001 case AUDIO_PCM_CMD_BIGENDIAN:
10002 {
10003 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10004 break;
10005 }
10006
10007 case AUDIO_PCM_CMD_TIMESTAMP:
10008 {
10009 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10010 break;
10011 }
10012
10013 case AUDIO_PCM_CMD_WEIGHTING:
10014 {
10015 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10016 break;
10017 }
10018
10019 case AUDIO_PCM_CMD_VOLUME:
10020 {
10021 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10022 break;
10023 }
10024
10025 case AUDIO_PCM_CMD_BUFFERLEVEL:
10026 {
10027 MS_U32 u32BufferLevel1 = 0;
10028 MS_U32 u32BufferLevel2 = 0;
10029 MS_U32 u32Timeout = 20;
10030
10031 while (u32Timeout > 0)
10032 {
10033 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0020);
10034 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10035 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10036 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0000);
10037
10038 if (u32BufferLevel1 == u32BufferLevel2)
10039 {
10040 break;
10041 }
10042
10043 u32Timeout--;
10044
10045 #ifdef MSOS_TYPE_LINUX_KERNEL
10046 udelay(1);
10047 #else
10048 AUDIO_DELAY1US(1);
10049 #endif
10050 }
10051
10052 if (u32BufferLevel1 != u32BufferLevel2)
10053 {
10054 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
10055 }
10056
10057 pPcmInfo->u32BufferLevel = u32BufferLevel2;
10058 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10059
10060 break;
10061 }
10062
10063 case AUDIO_PCM_CMD_MUTE:
10064 {
10065 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10066 break;
10067 }
10068
10069 case AUDIO_PCM_CMD_BUFFERSIZE:
10070 {
10071 *((MS_U32 *)pData) = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_size) * BYTES_IN_MIU_LINE;
10072 break;
10073 }
10074
10075 default:
10076 {
10077 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10078 break;
10079 }
10080 }
10081
10082 return s32Ret;
10083 }
10084
HAL_AUDIO_PCM_HwDma_Reader2_Write(const void * pBuf,MS_U32 u32Size)10085 MS_U32 HAL_AUDIO_PCM_HwDma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
10086 {
10087 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10088 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10089 MS_S8 *pBufTmp = NULL;
10090 MS_U32 u32BufferSize = 0;
10091 MS_U32 u32PcmLevel = 0;
10092 MS_U32 u32RequestSize = 0;
10093 MS_U32 u32RequestSizeTmp = 0;
10094 MS_U32 u32SizeToCopy = 0;
10095 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10096
10097 if (pBuf == NULL)
10098 {
10099 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10100 return 0;
10101 }
10102
10103 if (u32Size == 0)
10104 {
10105 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
10106 return 0;
10107 }
10108
10109 if (pPcmInfo->u8ConnectFlag == FALSE)
10110 {
10111 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10112 return 0;
10113 }
10114
10115 if (pPcmInfo->u8StartFlag == FALSE)
10116 {
10117 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
10118 return 0;
10119 }
10120
10121 pBufTmp = (MS_S8 *)pBuf;
10122
10123 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10124 if (u32PcmLevel == 0)
10125 {
10126 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10127 }
10128
10129 u32RequestSize = u32Size;
10130 u32RequestSizeTmp = u32RequestSize;
10131
10132 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
10133
10134 /* copy data to PCM buffer */
10135 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
10136 {
10137 do {
10138 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
10139 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
10140
10141 #ifdef MSOS_TYPE_LINUX_KERNEL
10142 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10143 #else
10144 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10145 #endif
10146
10147 pBufTmp += u32SizeToCopy;
10148 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
10149 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10150 {
10151 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10152 {
10153 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
10154 }
10155 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10156 }
10157
10158 u32RequestSizeTmp -= u32SizeToCopy;
10159 } while (u32RequestSizeTmp > 0);
10160
10161 /* flush MIU */
10162 MsOS_FlushMemory();
10163
10164 /* update copied size to engine */
10165 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
10166 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0000);
10167 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
10168 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0010);
10169 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
10170
10171 return u32Size;
10172 }
10173
10174 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
10175
10176 return 0;
10177 }
10178
HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)10179 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)
10180 {
10181 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10182 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10183 MS_S32 s32Ret = 0;
10184 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
10185
10186 if (pPcmInfo->u8StartFlag == FALSE)
10187 {
10188 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10189 HAL_AUDIO_PCM_HwDma_Reader2_Stop();
10190 }
10191
10192 return s32Ret;
10193 }
10194 #endif
10195
10196 #if AUDIO_SW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)10197 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)
10198 {
10199 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10200 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10201 MS_U16 u16Synthrate_H = 0;
10202 MS_U16 u16Synthrate_L = 0;
10203 MS_U32 u32TargetBufferSize = 0;
10204 MS_U32 u32TargetChannel = 0;
10205 MS_U32 u32TargetBitWidth = 0;
10206 MS_U32 u32TargetAlignmentSize = 0;
10207 MS_S32 s32Ret = 0;
10208
10209 switch(pPcmInfo->u32SampleRate) {
10210 case 8000:
10211 {
10212 u16Synthrate_H = 0x6978;
10213 u16Synthrate_L = 0x0000;
10214 break;
10215 }
10216
10217 case 11025:
10218 {
10219 u16Synthrate_H = 0x4C87;
10220 u16Synthrate_L = 0xD634;
10221 break;
10222 }
10223
10224 case 12000:
10225 {
10226 u16Synthrate_H = 0x4650;
10227 u16Synthrate_L = 0x0000;
10228 break;
10229 }
10230
10231 case 16000:
10232 {
10233 u16Synthrate_H = 0x34BC;
10234 u16Synthrate_L = 0x0000;
10235 break;
10236 }
10237
10238 case 22050:
10239 {
10240 u16Synthrate_H = 0x2643;
10241 u16Synthrate_L = 0xEB1A;
10242 break;
10243 }
10244
10245 case 24000:
10246 {
10247 u16Synthrate_H = 0x2328;
10248 u16Synthrate_L = 0x0000;
10249 break;
10250 }
10251
10252 case 32000:
10253 {
10254 u16Synthrate_H = 0x1A5E;
10255 u16Synthrate_L = 0x0000;
10256 break;
10257 }
10258
10259 case 44100:
10260 {
10261 u16Synthrate_H = 0x1321;
10262 u16Synthrate_L = 0xF58D;
10263 break;
10264 }
10265
10266 case 48000:
10267 {
10268 u16Synthrate_H = 0x1194;
10269 u16Synthrate_L = 0x0000;
10270 break;
10271 }
10272
10273 case 96000:
10274 {
10275 u16Synthrate_H = 0x08CA;
10276 u16Synthrate_L = 0x0000;
10277 break;
10278 }
10279
10280 default:
10281 {
10282 u16Synthrate_H = 0x1194;
10283 u16Synthrate_L = 0x0000;
10284 pPcmInfo->u32SampleRate = 48000;
10285 break;
10286 }
10287 }
10288
10289 /* enable reg_dvb5_fix_synth_nf_h */
10290 HAL_AUDIO_WriteMaskReg(0x2C24, 0xA000, 0xA000);
10291
10292 /* configure sample rate */
10293 HAL_AUDIO_WriteMaskReg(0x2C26, 0xFFFF, u16Synthrate_H);
10294 HAL_AUDIO_WriteMaskReg(0x2C28, 0xFFFF, u16Synthrate_L);
10295
10296 /* trigger reg_dvb5_fix_synth_nf_h to apply configuration */
10297 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x1000);
10298 #ifdef MSOS_TYPE_LINUX_KERNEL
10299 udelay(50);
10300 #else
10301 AUDIO_DELAY1US(50);
10302 #endif
10303 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x0000);
10304
10305 /* calculate buffer size */
10306 u32TargetChannel = 2;
10307 u32TargetBitWidth = 16;
10308 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10309 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10310 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10311 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10312 {
10313 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate);
10314 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10315 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10316 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
10317 }
10318
10319 pPCM->u8SettingChangeFlag = FALSE;
10320
10321 return s32Ret;
10322 }
10323
HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)10324 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)
10325 {
10326 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10327 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10328 MS_S32 s32Ret = 0;
10329
10330 if (pPcmInfo->u8ConnectFlag == FALSE)
10331 {
10332 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10333 return -A_EPERM;
10334 }
10335
10336 /* clear PCM buffer */
10337 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, SW_DMA_RDR1_BUF_SIZE);
10338
10339 /* flush MIU */
10340 MsOS_FlushMemory();
10341
10342 /* clear engine's write pointer */
10343 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, 0x0000);
10344
10345 /* reset engine, no start engine here! */
10346 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0001);
10347
10348 /* reset write pointer */
10349 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10350
10351 /* reset remain size */
10352 pPCM->tPcmBufferInfo.u32RemainSize = 0;
10353
10354 return s32Ret;
10355 }
10356
HAL_AUDIO_PCM_SwDma_Reader1_Open(void * pData)10357 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Open(void *pData)
10358 {
10359 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10360 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10361 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10362 MS_U32 u32TargetBufferAddrPa = 0;
10363 MS_U32 u32TargetBufferSize = 0;
10364 MS_U32 u32TargetChannel = 0;
10365 MS_U32 u32TargetBitWidth = 0;
10366 MS_U32 u32TargetAlignmentSize = 0;
10367 MS_S32 s32Ret = 0;
10368 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10369
10370 if (pData == NULL)
10371 {
10372 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10373 return -A_EFAULT;
10374 }
10375
10376 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10377
10378 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10379 {
10380 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10381 return -A_EINVAL;
10382 }
10383
10384 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10385 {
10386 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
10387 return -A_EINVAL;
10388 }
10389
10390 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10391 {
10392 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10393 return -A_EINVAL;
10394 }
10395
10396 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10397 {
10398 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10399 return -A_EINVAL;
10400 }
10401
10402 if (pUserPcmInfo->u8CaptureFlag == TRUE)
10403 {
10404 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
10405 return -A_EINVAL;
10406 }
10407
10408 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10409 {
10410 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
10411 return -A_EINVAL;
10412 }
10413
10414 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10415 {
10416 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
10417 return -A_EINVAL;
10418 }
10419
10420 /* calculate buffer size */
10421 u32TargetChannel = 2;
10422 u32TargetBitWidth = 16;
10423 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10424 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10425 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10426 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10427 {
10428 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate);
10429 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10430 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10431 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
10432 }
10433
10434 /* fill in settings */
10435 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10436 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10437 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10438 pPcmInfo->u8ConnectFlag = TRUE;
10439 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10440 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10441 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10442 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10443 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10444 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10445 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10446 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10447 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10448 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
10449 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10450 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10451
10452 /* init PCM buffer address */
10453 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + SW_DMA_RDR1_BUF_ADDR;
10454 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10455 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
10456 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10457
10458 /* apply setting */
10459 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
10460
10461 /* restart */
10462 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
10463
10464 /* TODO : force channel6 to SW DMA Reader, it's a hardcode */
10465 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x0F,0x00);
10466 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x82);
10467
10468 return s32Ret;
10469 }
10470
HAL_AUDIO_PCM_SwDma_Reader1_Close(void)10471 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Close(void)
10472 {
10473 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10474 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10475 MS_S32 s32Ret = 0;
10476 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10477
10478 if (pPcmInfo->u8ConnectFlag != FALSE)
10479 {
10480 HAL_AUDIO_PCM_SwDma_Reader1_Flush();
10481 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10482 }
10483
10484 return s32Ret;
10485 }
10486
HAL_AUDIO_PCM_SwDma_Reader1_Start(void)10487 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Start(void)
10488 {
10489 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10490 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10491 MS_S32 s32Ret = 0;
10492 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10493
10494 if (pPcmInfo->u8StartFlag == FALSE)
10495 {
10496 if (pPCM->u8SettingChangeFlag == TRUE)
10497 {
10498 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
10499 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
10500 }
10501
10502 /* start engine */
10503 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0002);
10504
10505 pPcmInfo->u8StartFlag = TRUE;
10506 }
10507
10508 return s32Ret;
10509 }
10510
HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)10511 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)
10512 {
10513 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10514 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10515 MS_S32 s32Ret = 0;
10516 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10517
10518 if (pPcmInfo->u8StartFlag != FALSE)
10519 {
10520 /* stop engine */
10521 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0000);
10522
10523 pPcmInfo->u8StartFlag = FALSE;
10524 }
10525
10526 return s32Ret;
10527 }
10528
HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)10529 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
10530 {
10531 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10532 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10533 MS_S32 s32Ret = 0;
10534 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10535
10536 if (pData == NULL)
10537 {
10538 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10539 return -A_EFAULT;
10540 }
10541
10542 if (pPcmInfo->u8ConnectFlag == FALSE)
10543 {
10544 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10545 return -A_EPERM;
10546 }
10547
10548 switch(u32Cmd)
10549 {
10550 case AUDIO_PCM_CMD_NONBLOCKING:
10551 {
10552 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10553
10554 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10555 {
10556 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10557 s32Ret = -A_EINVAL;
10558 break;
10559 }
10560
10561 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10562
10563 break;
10564 }
10565
10566 case AUDIO_PCM_CMD_MULTICH:
10567 {
10568 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10569
10570 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10571 {
10572 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10573 s32Ret = -A_EINVAL;
10574 break;
10575 }
10576
10577 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10578 {
10579 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10580 s32Ret = -A_EINVAL;
10581 break;
10582 }
10583
10584 pPcmInfo->u8MultiChFlag = FALSE;
10585
10586 break;
10587 }
10588
10589 case AUDIO_PCM_CMD_MIXING:
10590 {
10591 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10592
10593 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10594 {
10595 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10596 s32Ret = -A_EINVAL;
10597 break;
10598 }
10599
10600 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10601 {
10602 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10603 s32Ret = -A_EINVAL;
10604 break;
10605 }
10606
10607 pPcmInfo->u8MixingFlag = FALSE;
10608
10609 break;
10610 }
10611
10612 case AUDIO_PCM_CMD_MIXINGGROUP:
10613 {
10614 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10615
10616 pPcmInfo->u32MixingGroup = u32MixingGroup;
10617
10618 break;
10619 }
10620
10621 case AUDIO_PCM_CMD_BUFFERDURATION:
10622 {
10623 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
10624
10625 if (u32BufferDuration == 0)
10626 {
10627 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
10628 s32Ret = -A_EINVAL;
10629 break;
10630 }
10631
10632 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
10633 {
10634 pPcmInfo->u32BufferDuration = u32BufferDuration;
10635 pPCM->u8SettingChangeFlag = TRUE;
10636 }
10637
10638 break;
10639 }
10640
10641 case AUDIO_PCM_CMD_CHANNEL:
10642 {
10643 MS_U32 u32Channel = *((MS_U32 *)pData);
10644
10645 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10646 {
10647 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
10648 return -A_EINVAL;
10649 }
10650
10651 if (pPcmInfo->u32Channel != u32Channel)
10652 {
10653 pPcmInfo->u32Channel = u32Channel;
10654 pPCM->u8SettingChangeFlag = TRUE;
10655 }
10656
10657 break;
10658 }
10659
10660 case AUDIO_PCM_CMD_SAMPLERATE:
10661 {
10662 MS_U32 u32SampleRate = *((MS_U32 *)pData);
10663
10664 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10665 {
10666 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
10667 return -A_EINVAL;
10668 }
10669
10670 if (pPcmInfo->u32SampleRate != u32SampleRate)
10671 {
10672 pPcmInfo->u32SampleRate = u32SampleRate;
10673 pPCM->u8SettingChangeFlag = TRUE;
10674 }
10675
10676 break;
10677 }
10678
10679 case AUDIO_PCM_CMD_BITWIDTH:
10680 {
10681 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10682
10683 pPcmInfo->u32BitWidth = u32BitWidth;
10684
10685 break;
10686 }
10687
10688 case AUDIO_PCM_CMD_BIGENDIAN:
10689 {
10690 MS_U32 u32BigEndian = *((MS_U32 *)pData);
10691
10692 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
10693 {
10694 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
10695 return -A_EINVAL;
10696 }
10697
10698 pPcmInfo->u32BigEndian = u32BigEndian;
10699
10700 break;
10701 }
10702
10703 case AUDIO_PCM_CMD_TIMESTAMP:
10704 {
10705 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10706
10707 pPcmInfo->u32Timestamp = u32Timestamp;
10708
10709 break;
10710 }
10711
10712 case AUDIO_PCM_CMD_WEIGHTING:
10713 {
10714 MS_U32 u32Weighting = *((MS_U32 *)pData);
10715
10716 if (u32Weighting > 100)
10717 {
10718 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
10719 return -A_EINVAL;
10720 }
10721
10722 pPcmInfo->u32Weighting = u32Weighting;
10723
10724 break;
10725 }
10726
10727 case AUDIO_PCM_CMD_VOLUME:
10728 {
10729 MS_U32 u32Volume = *((MS_U32 *)pData);
10730
10731 if (u32Volume > 100)
10732 {
10733 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
10734 return -A_EINVAL;
10735 }
10736
10737 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
10738
10739 break;
10740 }
10741
10742 case AUDIO_PCM_CMD_MUTE:
10743 {
10744 MS_U32 u32Mute = *((MS_U32*)pData);
10745
10746 if (u32Mute == TRUE)
10747 {
10748 pPcmInfo->u32Volume |= 0x80000000;
10749 }
10750 else if (u32Mute == FALSE)
10751 {
10752 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10753 }
10754 else
10755 {
10756 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
10757 s32Ret = -A_EINVAL;
10758 }
10759 break;
10760 }
10761
10762 default:
10763 {
10764 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10765 break;
10766 }
10767 }
10768
10769 return s32Ret;
10770 }
10771
HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)10772 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
10773 {
10774 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10775 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10776 MS_S32 s32Ret = 0;
10777 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10778
10779 if (pData == NULL)
10780 {
10781 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10782 return -A_EFAULT;
10783 }
10784
10785 if (pPcmInfo->u8ConnectFlag == FALSE)
10786 {
10787 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10788 return -A_EPERM;
10789 }
10790
10791 switch(u32Cmd)
10792 {
10793 case AUDIO_PCM_CMD_ALL:
10794 {
10795 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10796 MS_U32 u32MinSize = 0;
10797
10798 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10799 {
10800 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10801 s32Ret = -A_EINVAL;
10802 break;
10803 }
10804 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
10805 {
10806 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10807 }
10808
10809 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
10810 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
10811 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
10812
10813 break;
10814 }
10815
10816 case AUDIO_PCM_CMD_NONBLOCKING:
10817 {
10818 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
10819 break;
10820 }
10821
10822 case AUDIO_PCM_CMD_MULTICH:
10823 {
10824 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
10825 break;
10826 }
10827
10828 case AUDIO_PCM_CMD_MIXING:
10829 {
10830 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
10831 break;
10832 }
10833
10834 case AUDIO_PCM_CMD_MIXINGGROUP:
10835 {
10836 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
10837 break;
10838 }
10839
10840 case AUDIO_PCM_CMD_BUFFER:
10841 {
10842 /*
10843 * TODO, need better coding
10844 *
10845 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
10846 */
10847 break;
10848 }
10849
10850 case AUDIO_PCM_CMD_BUFFERDURATION:
10851 {
10852 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
10853 break;
10854 }
10855
10856 case AUDIO_PCM_CMD_READPTR:
10857 {
10858 /*
10859 * TODO, need better coding
10860 *
10861 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
10862 */
10863 break;
10864 }
10865
10866 case AUDIO_PCM_CMD_WRITEPTR:
10867 {
10868 /*
10869 * TODO, need better coding
10870 *
10871 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
10872 */
10873 break;
10874 }
10875
10876 case AUDIO_PCM_CMD_CHANNEL:
10877 {
10878 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
10879 break;
10880 }
10881
10882 case AUDIO_PCM_CMD_SAMPLERATE:
10883 {
10884 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
10885 break;
10886 }
10887
10888 case AUDIO_PCM_CMD_BITWIDTH:
10889 {
10890 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10891 break;
10892 }
10893
10894 case AUDIO_PCM_CMD_BIGENDIAN:
10895 {
10896 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10897 break;
10898 }
10899
10900 case AUDIO_PCM_CMD_TIMESTAMP:
10901 {
10902 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10903 break;
10904 }
10905
10906 case AUDIO_PCM_CMD_WEIGHTING:
10907 {
10908 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10909 break;
10910 }
10911
10912 case AUDIO_PCM_CMD_VOLUME:
10913 {
10914 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10915 break;
10916 }
10917
10918 case AUDIO_PCM_CMD_BUFFERLEVEL:
10919 {
10920 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0008);
10921 pPcmInfo->u32BufferLevel = HAL_AUDIO_ReadReg(S2M_MBOX_SW_DMA_READER_DDR_Level) * BYTES_IN_MIU_LINE;
10922 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0000);
10923 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10924 break;
10925 }
10926
10927 case AUDIO_PCM_CMD_MUTE:
10928 {
10929 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10930 break;
10931 }
10932
10933 case AUDIO_PCM_CMD_BUFFERSIZE:
10934 {
10935 MS_U32 u32TargetBufferSize = 0;
10936 MS_U32 u32TargetChannel = 0;
10937 MS_U32 u32TargetBitWidth = 0;
10938
10939 u32TargetChannel = 2;
10940 u32TargetBitWidth = 16;
10941 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10942
10943 *((MS_U32 *)pData) = u32TargetBufferSize;
10944
10945 break;
10946 }
10947
10948 default:
10949 {
10950 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10951 break;
10952 }
10953 }
10954
10955 return s32Ret;
10956 }
10957
HAL_AUDIO_PCM_SwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)10958 MS_U32 HAL_AUDIO_PCM_SwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
10959 {
10960 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10961 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10962 MS_S8 *pBufTmp = NULL;
10963 MS_U32 u32BufferSize = 0;
10964 MS_U32 u32PcmLevel = 0;
10965 MS_U32 u32RequestSize = 0;
10966 MS_U32 u32RequestSizeTmp = 0;
10967 MS_U32 u32SizeToCopy = 0;
10968 MS_U32 u32WptrOffset = 0;
10969 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10970
10971 if (pBuf == NULL)
10972 {
10973 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10974 return 0;
10975 }
10976
10977 if (u32Size == 0)
10978 {
10979 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
10980 return 0;
10981 }
10982
10983 if (pPcmInfo->u8ConnectFlag == FALSE)
10984 {
10985 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10986 return 0;
10987 }
10988
10989 if (pPcmInfo->u8StartFlag == FALSE)
10990 {
10991 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
10992 return 0;
10993 }
10994
10995 pBufTmp = (MS_S8 *)pBuf;
10996
10997 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10998 if (u32PcmLevel == 0)
10999 {
11000 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11001 }
11002
11003 u32RequestSize = u32Size;
11004 u32RequestSizeTmp = u32RequestSize;
11005
11006 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
11007
11008 /* copy data to PCM buffer */
11009 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
11010 {
11011 do {
11012 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE) - pPCM->tPcmBufferInfo.pWritePtr;
11013 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11014
11015 #ifdef MSOS_TYPE_LINUX_KERNEL
11016 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11017 #else
11018 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11019 #endif
11020
11021 pBufTmp += u32SizeToCopy;
11022 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
11023 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11024 {
11025 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11026 {
11027 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11028 }
11029 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11030 }
11031
11032 u32RequestSizeTmp -= u32SizeToCopy;
11033 } while (u32RequestSizeTmp > 0);
11034
11035 /* flush MIU */
11036 MsOS_FlushMemory();
11037
11038 /* update write pointers to engine */
11039 u32WptrOffset = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pBuffer;
11040 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, (u32WptrOffset / BYTES_IN_MIU_LINE));
11041
11042 return u32Size;
11043 }
11044
11045 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
11046
11047 return 0;
11048 }
11049
HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)11050 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)
11051 {
11052 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11053 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11054 MS_S32 s32Ret = 0;
11055 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
11056
11057 if (pPcmInfo->u8StartFlag == FALSE)
11058 {
11059 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11060 HAL_AUDIO_PCM_SwDma_Reader1_Stop();
11061 }
11062
11063 return s32Ret;
11064 }
11065 #endif
11066
11067 #if AUDIO_R2_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)11068 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)
11069 {
11070 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11071 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11072 MS_U16 u16Val = 0;
11073 MS_U16 u16Synthrate_H = 0;
11074 MS_U16 u16Synthrate_L = 0;
11075 MS_U32 u32TargetBufferSize = 0;
11076 MS_U32 u32TargetChannel = 0;
11077 MS_U32 u32TargetBitWidth = 0;
11078 MS_U32 u32TargetAlignmentSize = 0;
11079 MS_S32 s32Ret = 0;
11080
11081 switch(pPcmInfo->u32SampleRate) {
11082 case 8000:
11083 {
11084 u16Synthrate_H = 0x6978;
11085 u16Synthrate_L = 0x0000;
11086 break;
11087 }
11088
11089 case 11025:
11090 {
11091 u16Synthrate_H = 0x4C87;
11092 u16Synthrate_L = 0xD634;
11093 break;
11094 }
11095
11096 case 12000:
11097 {
11098 u16Synthrate_H = 0x4650;
11099 u16Synthrate_L = 0x0000;
11100 break;
11101 }
11102
11103 case 16000:
11104 {
11105 u16Synthrate_H = 0x34BC;
11106 u16Synthrate_L = 0x0000;
11107 break;
11108 }
11109
11110 case 22050:
11111 {
11112 u16Synthrate_H = 0x2643;
11113 u16Synthrate_L = 0xEB1A;
11114 break;
11115 }
11116
11117 case 24000:
11118 {
11119 u16Synthrate_H = 0x2328;
11120 u16Synthrate_L = 0x0000;
11121 break;
11122 }
11123
11124 case 32000:
11125 {
11126 u16Synthrate_H = 0x1A5E;
11127 u16Synthrate_L = 0x0000;
11128 break;
11129 }
11130
11131 case 44100:
11132 {
11133 u16Synthrate_H = 0x1321;
11134 u16Synthrate_L = 0xF58D;
11135 break;
11136 }
11137
11138 case 48000:
11139 {
11140 u16Synthrate_H = 0x1194;
11141 u16Synthrate_L = 0x0000;
11142 break;
11143 }
11144
11145 case 96000:
11146 {
11147 u16Synthrate_H = 0x08CA;
11148 u16Synthrate_L = 0x0000;
11149 break;
11150 }
11151
11152 default:
11153 {
11154 u16Synthrate_H = 0x1194;
11155 u16Synthrate_L = 0x0000;
11156 pPcmInfo->u32SampleRate = 48000;
11157 break;
11158 }
11159 }
11160
11161 /* disable output */
11162 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x7FFF, 0x0000);
11163
11164 /* set synthesizer */
11165 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
11166 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
11167 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11168 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0101); /* SYTH1 bit8RIU control, bit0 update */
11169 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11170
11171 if (pPcmInfo->u8MultiChFlag == TRUE)
11172 {
11173 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11174 u32TargetChannel = 10;
11175 }
11176 else
11177 {
11178 /* stereo = 2 channels */
11179 u32TargetChannel = 2;
11180 }
11181
11182 /* calculate buffer size */
11183 u32TargetBitWidth = 16;
11184 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11185 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11186 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11187 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11188 {
11189 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate, u32TargetChannel);
11190 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11191 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11192 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
11193 }
11194
11195 /* set buffer size */
11196 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
11197
11198 /* set overrun & underrun threshold */
11199 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize >> 3)) / BYTES_IN_MIU_LINE));
11200 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
11201
11202 /* set channel mode */
11203 if (pPcmInfo->u8MultiChFlag == TRUE)
11204 {
11205 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11206 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x00);
11207 u16Val = 19; /* MIU burst length = 19 */
11208 u16Val += (1 << 7); /* MIU Step En = 1 */
11209 u16Val += (1 << 15); /* Sync Valid En = 1 */
11210 u16Val += (1 << 8); /* Sync Step Count = 1 */
11211 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11212 }
11213 else
11214 {
11215 /* Stereo mode : stereo = 2 channels */
11216 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x80);
11217 u16Val = 3; /* MIU burst length = 3 */
11218 u16Val += (0 << 7); /* MIU Step En = 0 */
11219 u16Val += (0 << 15); /* Sync Valid En = 0 */
11220 u16Val += (1 << 8); /* Sync Step Count = 1 */
11221 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11222 }
11223
11224 /* set 16 Bit mode */
11225 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0860, 0x0020);
11226
11227 pPCM->u8SettingChangeFlag = FALSE;
11228
11229 return s32Ret;
11230 }
11231
HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)11232 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)
11233 {
11234 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11235 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11236 MS_S32 s32Ret = 0;
11237
11238 if (pPcmInfo->u8ConnectFlag == FALSE)
11239 {
11240 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11241 return -A_EPERM;
11242 }
11243
11244 /* stop engine */
11245 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0000);
11246
11247 /* clear PCM buffer */
11248 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR1_BUF_SIZE);
11249
11250 /* flush MIU */
11251 MsOS_FlushMemory();
11252
11253 /* initial dlocal buffer */
11254 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x2000);
11255 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x0000);
11256
11257 /* reset engine */
11258 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x1000);
11259 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x0000);
11260
11261 /* start engine */
11262 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0002);
11263
11264 /* reset write pointer */
11265 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11266
11267 /* reset remain size */
11268 pPCM->tPcmBufferInfo.u32RemainSize = 0;
11269
11270 return s32Ret;
11271 }
11272
HAL_AUDIO_PCM_R2Dma_Reader1_Open(void * pData)11273 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Open(void *pData)
11274 {
11275 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11276 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11277 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
11278 MS_U32 u32TargetBufferAddrPa = 0;
11279 MS_U32 u32TargetBufferSize = 0;
11280 MS_U32 u32TargetChannel = 0;
11281 MS_U32 u32TargetBitWidth = 0;
11282 MS_U32 u32TargetAlignmentSize = 0;
11283 MS_S32 s32Ret = 0;
11284 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
11285
11286 if (pData == NULL)
11287 {
11288 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11289 return -A_EFAULT;
11290 }
11291
11292 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11293
11294 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11295 {
11296 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11297 return -A_EINVAL;
11298 }
11299
11300 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11301 {
11302 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
11303 return -A_EINVAL;
11304 }
11305
11306 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11307 {
11308 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11309 return -A_EINVAL;
11310 }
11311
11312 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11313 {
11314 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11315 return -A_EINVAL;
11316 }
11317
11318 if (pUserPcmInfo->u8CaptureFlag == TRUE)
11319 {
11320 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
11321 return -A_EINVAL;
11322 }
11323
11324 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11325 {
11326 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
11327 return -A_EINVAL;
11328 }
11329
11330 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
11331 {
11332 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
11333 return -A_EINVAL;
11334 }
11335
11336 if (pUserPcmInfo->u8MultiChFlag == TRUE)
11337 {
11338 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11339 u32TargetChannel = 10;
11340 }
11341 else
11342 {
11343 /* stereo = 2 channels */
11344 u32TargetChannel = 2;
11345 }
11346
11347 /* calculate buffer size */
11348 u32TargetBitWidth = 16;
11349 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11350 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11351 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11352 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11353 {
11354 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate, u32TargetChannel);
11355 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11356 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11357 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
11358 }
11359
11360 /* fill in settings */
11361 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11362 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
11363 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
11364 pPcmInfo->u8ConnectFlag = TRUE;
11365 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11366 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11367 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
11368 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
11369 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
11370 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
11371 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
11372 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
11373 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
11374 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
11375 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
11376 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
11377
11378 /* init DPGA */
11379 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x03, 0x03);
11380 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11381 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11382 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
11383 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_R_CTRL, 0x12, 0x12);
11384
11385 /* init PCM buffer address */
11386 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR1_BUF_ADDR;
11387 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
11388 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
11389 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11390
11391 /* switch R2_DMA & DPGA control to MCU */
11392 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x8000);
11393 HAL_AUR2_WriteMaskReg(R2_DMARDR1_EN, 0x0001, 0x0001);
11394
11395 /* set PCM buffer address */
11396 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
11397 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
11398
11399 /* apply setting */
11400 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11401
11402 /* restart */
11403 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11404
11405 /* TODO : force channel 1~4 to decoder1 when multi-channel output is configured, it's a hardcode */
11406 if (pPcmInfo->u8MultiChFlag == TRUE)
11407 {
11408 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
11409 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
11410 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
11411 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
11412 }
11413
11414 return s32Ret;
11415 }
11416
HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)11417 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)
11418 {
11419 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11420 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11421 MS_S32 s32Ret = 0;
11422 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11423
11424 if (pPcmInfo->u8ConnectFlag != FALSE)
11425 {
11426 HAL_AUDIO_PCM_R2Dma_Reader1_Flush();
11427 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11428 }
11429
11430 /* Switch R2_DMA & DPGA control to R2 */
11431 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x0000);
11432 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x01, 0x00);
11433
11434 return s32Ret;
11435 }
11436
HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)11437 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)
11438 {
11439 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11440 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11441 MS_S32 s32Ret = 0;
11442 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11443
11444 if (pPcmInfo->u8StartFlag == FALSE)
11445 {
11446 if (pPCM->u8SettingChangeFlag == TRUE)
11447 {
11448 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11449 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11450 }
11451
11452 /* enable engine's MIU access */
11453 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0001);
11454
11455 pPcmInfo->u8StartFlag = TRUE;
11456 }
11457
11458 return s32Ret;
11459 }
11460
HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)11461 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)
11462 {
11463 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11464 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11465 MS_S32 s32Ret = 0;
11466 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
11467
11468 if (pPcmInfo->u8StartFlag != FALSE)
11469 {
11470 /* disable engine's MIU access */
11471 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0000);
11472
11473 pPcmInfo->u8StartFlag = FALSE;
11474 }
11475
11476 return s32Ret;
11477 }
11478
HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd,const void * pData)11479 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
11480 {
11481 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11482 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11483 MS_S32 s32Ret = 0;
11484 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11485
11486 if (pData == NULL)
11487 {
11488 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11489 return -A_EFAULT;
11490 }
11491
11492 if (pPcmInfo->u8ConnectFlag == FALSE)
11493 {
11494 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11495 return -A_EPERM;
11496 }
11497
11498 switch(u32Cmd)
11499 {
11500 case AUDIO_PCM_CMD_NONBLOCKING:
11501 {
11502 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
11503
11504 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
11505 {
11506 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
11507 s32Ret = -A_EINVAL;
11508 break;
11509 }
11510
11511 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
11512
11513 break;
11514 }
11515
11516 case AUDIO_PCM_CMD_MULTICH:
11517 {
11518 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
11519
11520 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
11521 {
11522 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
11523 s32Ret = -A_EINVAL;
11524 break;
11525 }
11526
11527 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11528 {
11529 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11530 s32Ret = -A_EINVAL;
11531 break;
11532 }
11533
11534 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
11535
11536 break;
11537 }
11538
11539 case AUDIO_PCM_CMD_MIXING:
11540 {
11541 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
11542
11543 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
11544 {
11545 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
11546 s32Ret = -A_EINVAL;
11547 break;
11548 }
11549
11550 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11551 {
11552 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11553 s32Ret = -A_EINVAL;
11554 break;
11555 }
11556
11557 pPcmInfo->u8MixingFlag = FALSE;
11558
11559 break;
11560 }
11561
11562 case AUDIO_PCM_CMD_MIXINGGROUP:
11563 {
11564 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
11565
11566 pPcmInfo->u32MixingGroup = u32MixingGroup;
11567
11568 break;
11569 }
11570
11571 case AUDIO_PCM_CMD_BUFFERDURATION:
11572 {
11573 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
11574
11575 if (u32BufferDuration == 0)
11576 {
11577 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
11578 s32Ret = -A_EINVAL;
11579 break;
11580 }
11581
11582 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
11583 {
11584 pPcmInfo->u32BufferDuration = u32BufferDuration;
11585 pPCM->u8SettingChangeFlag = TRUE;
11586 }
11587
11588 break;
11589 }
11590
11591 case AUDIO_PCM_CMD_CHANNEL:
11592 {
11593 MS_U32 u32Channel = *((MS_U32 *)pData);
11594
11595 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11596 {
11597 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
11598 return -A_EINVAL;
11599 }
11600
11601 if (pPcmInfo->u32Channel != u32Channel)
11602 {
11603 pPcmInfo->u32Channel = u32Channel;
11604 pPCM->u8SettingChangeFlag = TRUE;
11605 }
11606
11607 break;
11608 }
11609
11610 case AUDIO_PCM_CMD_SAMPLERATE:
11611 {
11612 MS_U32 u32SampleRate = *((MS_U32 *)pData);
11613
11614 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
11615 {
11616 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
11617 return -A_EINVAL;
11618 }
11619
11620 if (pPcmInfo->u32SampleRate != u32SampleRate)
11621 {
11622 pPcmInfo->u32SampleRate = u32SampleRate;
11623 pPCM->u8SettingChangeFlag = TRUE;
11624 }
11625
11626 break;
11627 }
11628
11629 case AUDIO_PCM_CMD_BITWIDTH:
11630 {
11631 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11632
11633 pPcmInfo->u32BitWidth = u32BitWidth;
11634
11635 break;
11636 }
11637
11638 case AUDIO_PCM_CMD_BIGENDIAN:
11639 {
11640 MS_U32 u32BigEndian = *((MS_U32 *)pData);
11641
11642 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
11643 {
11644 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
11645 return -A_EINVAL;
11646 }
11647
11648 pPcmInfo->u32BigEndian = u32BigEndian;
11649
11650 break;
11651 }
11652
11653 case AUDIO_PCM_CMD_TIMESTAMP:
11654 {
11655 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11656
11657 pPcmInfo->u32Timestamp = u32Timestamp;
11658
11659 break;
11660 }
11661
11662 case AUDIO_PCM_CMD_WEIGHTING:
11663 {
11664 MS_U32 u32Weighting = *((MS_U32 *)pData);
11665
11666 if (u32Weighting > 100)
11667 {
11668 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
11669 return -A_EINVAL;
11670 }
11671
11672 pPcmInfo->u32Weighting = u32Weighting;
11673
11674 break;
11675 }
11676
11677 case AUDIO_PCM_CMD_VOLUME:
11678 {
11679 MS_U32 u32Volume = *((MS_U32 *)pData);
11680
11681 if (u32Volume > 100)
11682 {
11683 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
11684 return -A_EINVAL;
11685 }
11686
11687 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
11688
11689 break;
11690 }
11691
11692 case AUDIO_PCM_CMD_MUTE:
11693 {
11694 MS_U32 u32Mute = *((MS_U32*)pData);
11695
11696 if (u32Mute == TRUE)
11697 {
11698 pPcmInfo->u32Volume |= 0x80000000;
11699 }
11700 else if (u32Mute == FALSE)
11701 {
11702 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11703 }
11704 else
11705 {
11706 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
11707 s32Ret = -A_EINVAL;
11708 }
11709 break;
11710 }
11711
11712 default:
11713 {
11714 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11715 break;
11716 }
11717 }
11718
11719 return s32Ret;
11720 }
11721
HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd,void * pData)11722 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd, void *pData)
11723 {
11724 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11725 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11726 MS_S32 s32Ret = 0;
11727 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11728
11729 if (pData == NULL)
11730 {
11731 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11732 return -A_EFAULT;
11733 }
11734
11735 if (pPcmInfo->u8ConnectFlag == FALSE)
11736 {
11737 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11738 return -A_EPERM;
11739 }
11740
11741 switch(u32Cmd)
11742 {
11743 case AUDIO_PCM_CMD_ALL:
11744 {
11745 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11746 MS_U32 u32MinSize = 0;
11747
11748 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11749 {
11750 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11751 s32Ret = -A_EINVAL;
11752 break;
11753 }
11754 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
11755 {
11756 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11757 }
11758
11759 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
11760 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
11761 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
11762
11763 break;
11764 }
11765
11766 case AUDIO_PCM_CMD_NONBLOCKING:
11767 {
11768 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11769 break;
11770 }
11771
11772 case AUDIO_PCM_CMD_MULTICH:
11773 {
11774 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11775 break;
11776 }
11777
11778 case AUDIO_PCM_CMD_MIXING:
11779 {
11780 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11781 break;
11782 }
11783
11784 case AUDIO_PCM_CMD_MIXINGGROUP:
11785 {
11786 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11787 break;
11788 }
11789
11790 case AUDIO_PCM_CMD_BUFFER:
11791 {
11792 /*
11793 * TODO, need better coding
11794 *
11795 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
11796 */
11797 break;
11798 }
11799
11800 case AUDIO_PCM_CMD_BUFFERDURATION:
11801 {
11802 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11803 break;
11804 }
11805
11806 case AUDIO_PCM_CMD_READPTR:
11807 {
11808 /*
11809 * TODO, need better coding
11810 *
11811 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
11812 */
11813 break;
11814 }
11815
11816 case AUDIO_PCM_CMD_WRITEPTR:
11817 {
11818 /*
11819 * TODO, need better coding
11820 *
11821 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
11822 */
11823 break;
11824 }
11825
11826 case AUDIO_PCM_CMD_CHANNEL:
11827 {
11828 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11829 break;
11830 }
11831
11832 case AUDIO_PCM_CMD_SAMPLERATE:
11833 {
11834 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11835 break;
11836 }
11837
11838 case AUDIO_PCM_CMD_BITWIDTH:
11839 {
11840 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11841 break;
11842 }
11843
11844 case AUDIO_PCM_CMD_BIGENDIAN:
11845 {
11846 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
11847 break;
11848 }
11849
11850 case AUDIO_PCM_CMD_TIMESTAMP:
11851 {
11852 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11853 break;
11854 }
11855
11856 case AUDIO_PCM_CMD_WEIGHTING:
11857 {
11858 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11859 break;
11860 }
11861
11862 case AUDIO_PCM_CMD_VOLUME:
11863 {
11864 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
11865 break;
11866 }
11867
11868 case AUDIO_PCM_CMD_BUFFERLEVEL:
11869 {
11870 MS_U32 u32BufferLevel1 = 0;
11871 MS_U32 u32BufferLevel2 = 0;
11872 MS_U32 u32Timeout = 20;
11873
11874 while (u32Timeout > 0)
11875 {
11876 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
11877 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
11878
11879 if (u32BufferLevel1 == u32BufferLevel2)
11880 {
11881 break;
11882 }
11883
11884 u32Timeout--;
11885
11886 #ifdef MSOS_TYPE_LINUX_KERNEL
11887 udelay(1);
11888 #else
11889 AUDIO_DELAY1US(1);
11890 #endif
11891 }
11892
11893 if (u32BufferLevel1 != u32BufferLevel2)
11894 {
11895 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
11896 }
11897
11898 pPcmInfo->u32BufferLevel = u32BufferLevel2;
11899 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11900
11901 break;
11902 }
11903
11904 case AUDIO_PCM_CMD_MUTE:
11905 {
11906 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11907 break;
11908 }
11909
11910 case AUDIO_PCM_CMD_BUFFERSIZE:
11911 {
11912 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
11913 break;
11914 }
11915
11916 default:
11917 {
11918 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11919 break;
11920 }
11921 }
11922
11923 return s32Ret;
11924 }
11925
HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void * pBuf,MS_U32 u32Size)11926 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
11927 {
11928 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11929 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11930 MS_S8 *pBufTmp = NULL;
11931 MS_U32 u32BufferSize = 0;
11932 MS_U32 u32PcmLevel = 0;
11933 MS_U32 u32RequestSize = 0;
11934 MS_U32 u32RequestSizeTmp = 0;
11935 MS_U32 u32SizeToCopy = 0;
11936 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11937
11938 if (pBuf == NULL)
11939 {
11940 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11941 return 0;
11942 }
11943
11944 if (u32Size == 0)
11945 {
11946 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
11947 return 0;
11948 }
11949
11950 if (pPcmInfo->u8ConnectFlag == FALSE)
11951 {
11952 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11953 return 0;
11954 }
11955
11956 if (pPcmInfo->u8StartFlag == FALSE)
11957 {
11958 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
11959 return 0;
11960 }
11961
11962 /*
11963 * A patch here!
11964 * to ensure channel 1~4 are configured as decoder1
11965 */
11966 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x80) ||
11967 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x80) ||
11968 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x80) ||
11969 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x80))
11970 {
11971 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
11972 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
11973 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
11974 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
11975 }
11976
11977 pBufTmp = (MS_S8 *)pBuf;
11978
11979 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
11980 if (u32PcmLevel == 0)
11981 {
11982 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11983 }
11984
11985 u32RequestSize = u32Size;
11986 u32RequestSizeTmp = u32RequestSize;
11987
11988 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
11989
11990 /* copy data to PCM buffer */
11991 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
11992 {
11993 do {
11994 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
11995 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11996
11997 #ifdef MSOS_TYPE_LINUX_KERNEL
11998 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11999 #else
12000 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12001 #endif
12002
12003 pBufTmp += u32SizeToCopy;
12004 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
12005 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12006 {
12007 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12008 {
12009 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12010 }
12011 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12012 }
12013
12014 u32RequestSizeTmp -= u32SizeToCopy;
12015 } while (u32RequestSizeTmp > 0);
12016
12017 /* flush MIU */
12018 MsOS_FlushMemory();
12019
12020 /* update copied size to engine */
12021 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
12022 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
12023 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0400);
12024 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0000);
12025 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
12026
12027 return u32Size;
12028 }
12029
12030 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
12031
12032 return 0;
12033 }
12034
HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)12035 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)
12036 {
12037 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12038 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12039 MS_S32 s32Ret = 0;
12040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12041
12042 if (pPcmInfo->u8StartFlag == FALSE)
12043 {
12044 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
12045 HAL_AUDIO_PCM_R2Dma_Reader1_Stop();
12046 }
12047
12048 return s32Ret;
12049 }
12050 #endif
12051
12052 #if AUDIO_R2_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)12053 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)
12054 {
12055 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12056 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12057 MS_U16 u16Val = 0;
12058 MS_U16 u16Synthrate_H = 0;
12059 MS_U16 u16Synthrate_L = 0;
12060 MS_U32 u32TargetBufferSize = 0;
12061 MS_U32 u32TargetChannel = 0;
12062 MS_U32 u32TargetBitWidth = 0;
12063 MS_U32 u32TargetAlignmentSize = 0;
12064 MS_S32 s32Ret = 0;
12065
12066 switch(pPcmInfo->u32SampleRate) {
12067 case 8000:
12068 {
12069 u16Synthrate_H = 0x6978;
12070 u16Synthrate_L = 0x0000;
12071 break;
12072 }
12073
12074 case 11025:
12075 {
12076 u16Synthrate_H = 0x4C87;
12077 u16Synthrate_L = 0xD634;
12078 break;
12079 }
12080
12081 case 12000:
12082 {
12083 u16Synthrate_H = 0x4650;
12084 u16Synthrate_L = 0x0000;
12085 break;
12086 }
12087
12088 case 16000:
12089 {
12090 u16Synthrate_H = 0x34BC;
12091 u16Synthrate_L = 0x0000;
12092 break;
12093 }
12094
12095 case 22050:
12096 {
12097 u16Synthrate_H = 0x2643;
12098 u16Synthrate_L = 0xEB1A;
12099 break;
12100 }
12101
12102 case 24000:
12103 {
12104 u16Synthrate_H = 0x2328;
12105 u16Synthrate_L = 0x0000;
12106 break;
12107 }
12108
12109 case 32000:
12110 {
12111 u16Synthrate_H = 0x1A5E;
12112 u16Synthrate_L = 0x0000;
12113 break;
12114 }
12115
12116 case 44100:
12117 {
12118 u16Synthrate_H = 0x1321;
12119 u16Synthrate_L = 0xF58D;
12120 break;
12121 }
12122
12123 case 48000:
12124 {
12125 u16Synthrate_H = 0x1194;
12126 u16Synthrate_L = 0x0000;
12127 break;
12128 }
12129
12130 case 96000:
12131 {
12132 u16Synthrate_H = 0x08CA;
12133 u16Synthrate_L = 0x0000;
12134 break;
12135 }
12136
12137 default:
12138 {
12139 u16Synthrate_H = 0x1194;
12140 u16Synthrate_L = 0x0000;
12141 pPcmInfo->u32SampleRate = 48000;
12142 break;
12143 }
12144 }
12145
12146 /* disable output */
12147 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x7FFF, 0x0000);
12148
12149 /* set synthesizer */
12150 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
12151 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
12152 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12153 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0404); /* SYTH3 bit10 RIU control, bit3 update */
12154 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12155
12156 if (pPcmInfo->u8MultiChFlag == TRUE)
12157 {
12158 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12159 u32TargetChannel = 10;
12160 }
12161 else
12162 {
12163 /* stereo = 2 channels */
12164 u32TargetChannel = 2;
12165 }
12166
12167 /* calculate buffer size */
12168 u32TargetBitWidth = 16;
12169 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12170 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12171 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12172 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12173 {
12174 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate, u32TargetChannel);
12175 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12176 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12177 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
12178 }
12179
12180 /* set buffer size */
12181 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
12182
12183 /* set overrun & underrun threshold */
12184 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize>> 3)) / BYTES_IN_MIU_LINE));
12185 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
12186
12187 /* set channel mode */
12188 if (pPcmInfo->u8MultiChFlag == TRUE)
12189 {
12190 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12191 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x00);
12192 u16Val = 19; /* MIU burst length = 19 */
12193 u16Val += (1 << 7); /* MIU Step En = 1 */
12194 u16Val += (1 << 15); /* Sync Valid En = 1 */
12195 u16Val += (1 << 8); /* Sync Step Count = 1 */
12196 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12197 }
12198 else
12199 {
12200 /* Stereo mode : stereo = 2 channels */
12201 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x80);
12202 u16Val = 3; /* MIU burst length = 3 */
12203 u16Val += (0 << 7); /* MIU Step En = 0 */
12204 u16Val += (0 << 15); /* Sync Valid En = 0 */
12205 u16Val += (1 << 8); /* Sync Step Count = 1 */
12206 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12207 }
12208
12209 /* set 16 Bit mode */
12210 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0860, 0x0020);
12211
12212 pPCM->u8SettingChangeFlag = FALSE;
12213
12214 return s32Ret;
12215 }
12216
HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)12217 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)
12218 {
12219 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12220 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12221 MS_S32 s32Ret = 0;
12222
12223 if (pPcmInfo->u8ConnectFlag == FALSE)
12224 {
12225 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12226 return -A_EPERM;
12227 }
12228
12229 /* stop engine */
12230 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0000);
12231
12232 /* clear PCM buffer */
12233 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR2_BUF_SIZE);
12234
12235 /* flush MIU */
12236 MsOS_FlushMemory();
12237
12238 /* initial dlocal buffer */
12239 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x2000);
12240 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x0000);
12241
12242 /* reset engine */
12243 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x1000);
12244 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x0000);
12245
12246 /* start engine */
12247 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0002);
12248
12249 /* reset write pointer */
12250 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12251
12252 /* reset remain size */
12253 pPCM->tPcmBufferInfo.u32RemainSize = 0;
12254
12255 return s32Ret;
12256 }
12257
HAL_AUDIO_PCM_R2Dma_Reader2_Open(void * pData)12258 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Open(void *pData)
12259 {
12260 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12261 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12262 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
12263 MS_U32 u32TargetBufferAddrPa = 0;
12264 MS_U32 u32TargetBufferSize = 0;
12265 MS_U32 u32TargetChannel = 0;
12266 MS_U32 u32TargetBitWidth = 0;
12267 MS_U32 u32TargetAlignmentSize = 0;
12268 MS_S32 s32Ret = 0;
12269 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
12270
12271 if (pData == NULL)
12272 {
12273 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12274 return -A_EFAULT;
12275 }
12276
12277 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12278
12279 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12280 {
12281 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12282 return -A_EINVAL;
12283 }
12284
12285 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12286 {
12287 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
12288 return -A_EINVAL;
12289 }
12290
12291 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12292 {
12293 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12294 return -A_EINVAL;
12295 }
12296
12297 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12298 {
12299 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12300 return -A_EINVAL;
12301 }
12302
12303 if (pUserPcmInfo->u8CaptureFlag == TRUE)
12304 {
12305 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
12306 return -A_EINVAL;
12307 }
12308
12309 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12310 {
12311 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
12312 return -A_EINVAL;
12313 }
12314
12315 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12316 {
12317 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
12318 return -A_EINVAL;
12319 }
12320
12321 if (pUserPcmInfo->u8MultiChFlag == TRUE)
12322 {
12323 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12324 u32TargetChannel = 10;
12325 }
12326 else
12327 {
12328 /* stereo = 2 channels */
12329 u32TargetChannel = 2;
12330 }
12331
12332 /* calculate buffer size */
12333 u32TargetBitWidth = 16;
12334 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12335 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12336 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12337 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12338 {
12339 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate, u32TargetChannel);
12340 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12341 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12342 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
12343 }
12344
12345 /* fill in settings */
12346 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12347 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
12348 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
12349 pPcmInfo->u8ConnectFlag = TRUE;
12350 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12351 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12352 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
12353 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
12354 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
12355 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
12356 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
12357 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
12358 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
12359 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
12360 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
12361 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
12362
12363 /* init DPGA */
12364 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x03, 0x03);
12365 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12366 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12367 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
12368 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_R_CTRL, 0x12, 0x12);
12369
12370 /* init PCM buffer address */
12371 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR2_BUF_ADDR;
12372 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
12373 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
12374 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12375
12376 /* switch R2_DMA & DPGA control to MCU */
12377 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x8000);
12378 HAL_AUR2_WriteMaskReg(R2_DMARDR2_EN, 0x0001, 0x0001);
12379
12380 /* set PCM buffer address */
12381 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
12382 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
12383
12384 /* apply setting */
12385 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12386
12387 /* restart */
12388 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12389
12390 /* TODO : force channel 1~4 to decoder3 when multi-channel output is configured, it's a hardcode */
12391 if (pPcmInfo->u8MultiChFlag == TRUE)
12392 {
12393 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
12394 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
12395 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
12396 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
12397 }
12398
12399 return s32Ret;
12400 }
12401
HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)12402 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)
12403 {
12404 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12405 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12406 MS_S32 s32Ret = 0;
12407 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
12408
12409 if (pPcmInfo->u8ConnectFlag != FALSE)
12410 {
12411 HAL_AUDIO_PCM_R2Dma_Reader2_Flush();
12412 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12413 }
12414
12415 /* switch R2_DMA & DPGA control to R2 */
12416 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x0000);
12417 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x01, 0x00);
12418
12419 return s32Ret;
12420 }
12421
HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)12422 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)
12423 {
12424 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12425 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12426 MS_S32 s32Ret = 0;
12427 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
12428
12429 if (pPcmInfo->u8StartFlag == FALSE)
12430 {
12431 if (pPCM->u8SettingChangeFlag == TRUE)
12432 {
12433 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12434 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12435 }
12436
12437 /* enable engine's MIU access */
12438 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0001);
12439
12440 pPcmInfo->u8StartFlag = TRUE;
12441 }
12442
12443 return s32Ret;
12444 }
12445
HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)12446 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)
12447 {
12448 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12449 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12450 MS_S32 s32Ret = 0;
12451 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
12452
12453 if (pPcmInfo->u8StartFlag != FALSE)
12454 {
12455 /* disable engine's MIU access */
12456 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0000);
12457
12458 pPcmInfo->u8StartFlag = FALSE;
12459 }
12460
12461 return s32Ret;
12462 }
12463
HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd,const void * pData)12464 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
12465 {
12466 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12467 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12468 MS_S32 s32Ret = 0;
12469 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12470
12471 if (pData == NULL)
12472 {
12473 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12474 return -A_EFAULT;
12475 }
12476
12477 if (pPcmInfo->u8ConnectFlag == FALSE)
12478 {
12479 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12480 return -A_EPERM;
12481 }
12482
12483 switch(u32Cmd)
12484 {
12485 case AUDIO_PCM_CMD_NONBLOCKING:
12486 {
12487 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
12488
12489 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
12490 {
12491 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
12492 s32Ret = -A_EINVAL;
12493 break;
12494 }
12495
12496 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
12497
12498 break;
12499 }
12500
12501 case AUDIO_PCM_CMD_MULTICH:
12502 {
12503 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
12504
12505 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
12506 {
12507 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
12508 s32Ret = -A_EINVAL;
12509 break;
12510 }
12511
12512 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12513 {
12514 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12515 s32Ret = -A_EINVAL;
12516 break;
12517 }
12518
12519 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
12520
12521 break;
12522 }
12523
12524 case AUDIO_PCM_CMD_MIXING:
12525 {
12526 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
12527
12528 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
12529 {
12530 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
12531 s32Ret = -A_EINVAL;
12532 break;
12533 }
12534
12535 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12536 {
12537 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12538 s32Ret = -A_EINVAL;
12539 break;
12540 }
12541
12542 pPcmInfo->u8MixingFlag = FALSE;
12543
12544 break;
12545 }
12546
12547 case AUDIO_PCM_CMD_MIXINGGROUP:
12548 {
12549 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
12550
12551 pPcmInfo->u32MixingGroup = u32MixingGroup;
12552
12553 break;
12554 }
12555
12556 case AUDIO_PCM_CMD_BUFFERDURATION:
12557 {
12558 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
12559
12560 if (u32BufferDuration == 0)
12561 {
12562 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
12563 s32Ret = -A_EINVAL;
12564 break;
12565 }
12566
12567 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
12568 {
12569 pPcmInfo->u32BufferDuration = u32BufferDuration;
12570 pPCM->u8SettingChangeFlag = TRUE;
12571 }
12572
12573 break;
12574 }
12575
12576 case AUDIO_PCM_CMD_CHANNEL:
12577 {
12578 MS_U32 u32Channel = *((MS_U32 *)pData);
12579
12580 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12581 {
12582 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
12583 return -A_EINVAL;
12584 }
12585
12586 if (pPcmInfo->u32Channel != u32Channel)
12587 {
12588 pPcmInfo->u32Channel = u32Channel;
12589 pPCM->u8SettingChangeFlag = TRUE;
12590 }
12591
12592 break;
12593 }
12594
12595 case AUDIO_PCM_CMD_SAMPLERATE:
12596 {
12597 MS_U32 u32SampleRate = *((MS_U32 *)pData);
12598
12599 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12600 {
12601 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
12602 return -A_EINVAL;
12603 }
12604
12605 if (pPcmInfo->u32SampleRate != u32SampleRate)
12606 {
12607 pPcmInfo->u32SampleRate = u32SampleRate;
12608 pPCM->u8SettingChangeFlag = TRUE;
12609 }
12610
12611 break;
12612 }
12613
12614 case AUDIO_PCM_CMD_BITWIDTH:
12615 {
12616 MS_U32 u32BitWidth = *((MS_U32 *)pData);
12617
12618 pPcmInfo->u32BitWidth = u32BitWidth;
12619
12620 break;
12621 }
12622
12623 case AUDIO_PCM_CMD_BIGENDIAN:
12624 {
12625 MS_U32 u32BigEndian = *((MS_U32 *)pData);
12626
12627 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
12628 {
12629 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
12630 return -A_EINVAL;
12631 }
12632
12633 pPcmInfo->u32BigEndian = u32BigEndian;
12634
12635 break;
12636 }
12637
12638 case AUDIO_PCM_CMD_TIMESTAMP:
12639 {
12640 MS_U32 u32Timestamp = *((MS_U32 *)pData);
12641
12642 pPcmInfo->u32Timestamp = u32Timestamp;
12643
12644 break;
12645 }
12646
12647 case AUDIO_PCM_CMD_WEIGHTING:
12648 {
12649 MS_U32 u32Weighting = *((MS_U32 *)pData);
12650
12651 if (u32Weighting > 100)
12652 {
12653 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
12654 return -A_EINVAL;
12655 }
12656
12657 pPcmInfo->u32Weighting = u32Weighting;
12658
12659 break;
12660 }
12661
12662 case AUDIO_PCM_CMD_VOLUME:
12663 {
12664 MS_U32 u32Volume = *((MS_U32 *)pData);
12665
12666 if (u32Volume > 100)
12667 {
12668 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
12669 return -A_EINVAL;
12670 }
12671
12672 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
12673
12674 break;
12675 }
12676
12677 case AUDIO_PCM_CMD_MUTE:
12678 {
12679 MS_U32 u32Mute = *((MS_U32*)pData);
12680
12681 if (u32Mute == TRUE)
12682 {
12683 pPcmInfo->u32Volume |= 0x80000000;
12684 }
12685 else if (u32Mute == FALSE)
12686 {
12687 pPcmInfo->u32Volume &= 0x7FFFFFFF;
12688 }
12689 else
12690 {
12691 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
12692 s32Ret = -A_EINVAL;
12693 }
12694 break;
12695 }
12696
12697 default:
12698 {
12699 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12700 break;
12701 }
12702 }
12703
12704 return s32Ret;
12705 }
12706
HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd,void * pData)12707 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd, void *pData)
12708 {
12709 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12710 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12711 MS_S32 s32Ret = 0;
12712 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12713
12714 if (pData == NULL)
12715 {
12716 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12717 return -A_EFAULT;
12718 }
12719
12720 if (pPcmInfo->u8ConnectFlag == FALSE)
12721 {
12722 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12723 return -A_EPERM;
12724 }
12725
12726 switch(u32Cmd)
12727 {
12728 case AUDIO_PCM_CMD_ALL:
12729 {
12730 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12731 MS_U32 u32MinSize = 0;
12732
12733 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12734 {
12735 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12736 s32Ret = -A_EINVAL;
12737 break;
12738 }
12739 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
12740 {
12741 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12742 }
12743
12744 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
12745 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
12746 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
12747
12748 break;
12749 }
12750
12751 case AUDIO_PCM_CMD_NONBLOCKING:
12752 {
12753 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
12754 break;
12755 }
12756
12757 case AUDIO_PCM_CMD_MULTICH:
12758 {
12759 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
12760 break;
12761 }
12762
12763 case AUDIO_PCM_CMD_MIXING:
12764 {
12765 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
12766 break;
12767 }
12768
12769 case AUDIO_PCM_CMD_MIXINGGROUP:
12770 {
12771 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
12772 break;
12773 }
12774
12775 case AUDIO_PCM_CMD_BUFFER:
12776 {
12777 /*
12778 * TODO, need better coding
12779 *
12780 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
12781 */
12782 break;
12783 }
12784
12785 case AUDIO_PCM_CMD_BUFFERDURATION:
12786 {
12787 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
12788 break;
12789 }
12790
12791 case AUDIO_PCM_CMD_READPTR:
12792 {
12793 /*
12794 * TODO, need better coding
12795 *
12796 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
12797 */
12798 break;
12799 }
12800
12801 case AUDIO_PCM_CMD_WRITEPTR:
12802 {
12803 /*
12804 * TODO, need better coding
12805 *
12806 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
12807 */
12808 break;
12809 }
12810
12811 case AUDIO_PCM_CMD_CHANNEL:
12812 {
12813 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
12814 break;
12815 }
12816
12817 case AUDIO_PCM_CMD_SAMPLERATE:
12818 {
12819 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
12820 break;
12821 }
12822
12823 case AUDIO_PCM_CMD_BITWIDTH:
12824 {
12825 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
12826 break;
12827 }
12828
12829 case AUDIO_PCM_CMD_BIGENDIAN:
12830 {
12831 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
12832 break;
12833 }
12834
12835 case AUDIO_PCM_CMD_TIMESTAMP:
12836 {
12837 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
12838 break;
12839 }
12840
12841 case AUDIO_PCM_CMD_WEIGHTING:
12842 {
12843 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
12844 break;
12845 }
12846
12847 case AUDIO_PCM_CMD_VOLUME:
12848 {
12849 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
12850 break;
12851 }
12852
12853 case AUDIO_PCM_CMD_BUFFERLEVEL:
12854 {
12855 MS_U32 u32BufferLevel1 = 0;
12856 MS_U32 u32BufferLevel2 = 0;
12857 MS_U32 u32Timeout = 20;
12858
12859 while (u32Timeout > 0)
12860 {
12861 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12862 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12863
12864 if (u32BufferLevel1 == u32BufferLevel2)
12865 {
12866 break;
12867 }
12868
12869 u32Timeout--;
12870
12871 #ifdef MSOS_TYPE_LINUX_KERNEL
12872 udelay(1);
12873 #else
12874 AUDIO_DELAY1US(1);
12875 #endif
12876 }
12877
12878 if (u32BufferLevel1 != u32BufferLevel2)
12879 {
12880 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
12881 }
12882
12883 pPcmInfo->u32BufferLevel = u32BufferLevel2;
12884 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12885
12886 break;
12887 }
12888
12889 case AUDIO_PCM_CMD_MUTE:
12890 {
12891 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12892 break;
12893 }
12894
12895 case AUDIO_PCM_CMD_BUFFERSIZE:
12896 {
12897 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
12898 break;
12899 }
12900
12901 default:
12902 {
12903 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12904 break;
12905 }
12906 }
12907
12908 return s32Ret;
12909 }
12910
HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void * pBuf,MS_U32 u32Size)12911 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
12912 {
12913 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12914 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12915 MS_S8 *pBufTmp = NULL;
12916 MS_U32 u32BufferSize = 0;
12917 MS_U32 u32PcmLevel = 0;
12918 MS_U32 u32RequestSize = 0;
12919 MS_U32 u32RequestSizeTmp = 0;
12920 MS_U32 u32SizeToCopy = 0;
12921 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
12922
12923 if (pBuf == NULL)
12924 {
12925 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
12926 return 0;
12927 }
12928
12929 if (u32Size == 0)
12930 {
12931 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
12932 return 0;
12933 }
12934
12935 if (pPcmInfo->u8ConnectFlag == FALSE)
12936 {
12937 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12938 return 0;
12939 }
12940
12941 if (pPcmInfo->u8StartFlag == FALSE)
12942 {
12943 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
12944 return 0;
12945 }
12946
12947 /*
12948 * A patch here!
12949 * to ensure channel 1~4 are configured as decoder3
12950 */
12951 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x82) ||
12952 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x82) ||
12953 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x82) ||
12954 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x82))
12955 {
12956 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
12957 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
12958 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
12959 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
12960 }
12961
12962 pBufTmp = (MS_S8 *)pBuf;
12963
12964 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12965 if (u32PcmLevel == 0)
12966 {
12967 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
12968 }
12969
12970 u32RequestSize = u32Size;
12971 u32RequestSizeTmp = u32RequestSize;
12972
12973 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
12974
12975 /* copy data to PCM buffer */
12976 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
12977 {
12978 do {
12979 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
12980 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12981
12982 #ifdef MSOS_TYPE_LINUX_KERNEL
12983 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12984 #else
12985 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12986 #endif
12987
12988 pBufTmp += u32SizeToCopy;
12989 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
12990 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12991 {
12992 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12993 {
12994 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12995 }
12996 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12997 }
12998
12999 u32RequestSizeTmp -= u32SizeToCopy;
13000 } while (u32RequestSizeTmp > 0);
13001
13002 /* flush MIU */
13003 MsOS_FlushMemory();
13004
13005 /* update copied size to engine */
13006 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
13007 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
13008 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0400);
13009 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0000);
13010 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
13011
13012 return u32Size;
13013 }
13014
13015 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
13016
13017 return 0;
13018 }
13019
HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)13020 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)
13021 {
13022 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13023 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13024 MS_S32 s32Ret = 0;
13025 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13026
13027 if (pPcmInfo->u8StartFlag == FALSE)
13028 {
13029 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
13030 HAL_AUDIO_PCM_R2Dma_Reader2_Stop();
13031 }
13032
13033 return s32Ret;
13034 }
13035 #endif
13036
13037 #if AUDIO_PCM_CAPTURE1_SUPPORT
HAL_AUDIO_PCM_Capture1_Restart(void)13038 MS_S32 HAL_AUDIO_PCM_Capture1_Restart(void)
13039 {
13040 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13041 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13042 MS_U32 u32WritePtrOffset = 0;
13043 MS_U32 u32TimeoutCounter = 0;
13044 MS_S32 s32Ret = 0;
13045
13046 if (pPcmInfo->u8ConnectFlag == FALSE)
13047 {
13048 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13049 return -A_EPERM;
13050 }
13051
13052 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0x0000);
13053
13054 do {
13055 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13056
13057 if (u32WritePtrOffset != 0)
13058 {
13059 #ifdef MSOS_TYPE_LINUX_KERNEL
13060 udelay(50);
13061 #else
13062 AUDIO_DELAY1US(50);
13063 #endif
13064 u32TimeoutCounter++;
13065 }
13066 else
13067 {
13068 break;
13069 }
13070 } while (u32TimeoutCounter < 10000);
13071
13072 /* clear PCM buffer */
13073 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE1_BUF_SIZE);
13074
13075 /* flush MIU */
13076 MsOS_FlushMemory();
13077
13078 /* reset PCM capture1 read & write pointer */
13079 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13080 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13081 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0x0000);
13082
13083 return s32Ret;
13084 }
13085
HAL_AUDIO_PCM_Capture1_Open(void * pData)13086 MS_S32 HAL_AUDIO_PCM_Capture1_Open(void *pData)
13087 {
13088 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13089 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13090 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13091 MS_U32 u32TargetBufferAddrPa = 0;
13092 MS_S32 s32Ret = 0;
13093 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13094
13095 if (pData == NULL)
13096 {
13097 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13098 return -A_EFAULT;
13099 }
13100
13101 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13102
13103 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13104 {
13105 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13106 return -A_EINVAL;
13107 }
13108
13109 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13110 {
13111 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
13112 return -A_EINVAL;
13113 }
13114
13115 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13116 {
13117 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13118 return -A_EINVAL;
13119 }
13120
13121 if (pUserPcmInfo->u8MixingFlag == TRUE)
13122 {
13123 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13124 return -A_EINVAL;
13125 }
13126
13127 if (pUserPcmInfo->u8CaptureFlag != TRUE)
13128 {
13129 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
13130 return -A_EINVAL;
13131 }
13132
13133 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
13134 {
13135 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13136 return -A_EINVAL;
13137 }
13138
13139 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
13140 {
13141 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13142 return -A_EINVAL;
13143 }
13144
13145 /* fill in settings */
13146 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13147 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13148 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13149 pPcmInfo->u8ConnectFlag = TRUE;
13150 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13151 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13152 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13153 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13154 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13155 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
13156 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
13157 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
13158 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13159 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13160 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13161 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13162
13163 /* init PCM buffer address */
13164 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
13165 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13166 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13167 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13168
13169 /* restart */
13170 HAL_AUDIO_PCM_Capture1_Restart();
13171
13172 return s32Ret;
13173 }
13174
HAL_AUDIO_PCM_Capture1_Close(void)13175 MS_S32 HAL_AUDIO_PCM_Capture1_Close(void)
13176 {
13177 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13178 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13179 MS_S32 s32Ret = 0;
13180 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13181
13182 if (pPcmInfo->u8ConnectFlag != FALSE)
13183 {
13184 HAL_AUDIO_PCM_Capture1_Flush();
13185 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13186 }
13187
13188 return s32Ret;
13189 }
13190
HAL_AUDIO_PCM_Capture1_Start(void)13191 MS_S32 HAL_AUDIO_PCM_Capture1_Start(void)
13192 {
13193 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13194 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13195 MS_U32 u32BufferSize = 0;
13196 MS_S32 s32Ret = 0;
13197 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13198
13199 if (pPcmInfo->u8StartFlag == FALSE)
13200 {
13201 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13202 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
13203
13204 pPcmInfo->u8StartFlag = TRUE;
13205 }
13206
13207 return s32Ret;
13208 }
13209
HAL_AUDIO_PCM_Capture1_Stop(void)13210 MS_S32 HAL_AUDIO_PCM_Capture1_Stop(void)
13211 {
13212 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13213 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13214 MS_S32 s32Ret = 0;
13215 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13216
13217 if (pPcmInfo->u8StartFlag != FALSE)
13218 {
13219 /* TODO, there is no such control in DSP */
13220
13221 pPcmInfo->u8StartFlag = FALSE;
13222 }
13223
13224 return s32Ret;
13225 }
13226
HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd,const void * pData)13227 MS_S32 HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd, const void *pData)
13228 {
13229 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13230 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13231 MS_S32 s32Ret = 0;
13232 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13233
13234 if (pData == NULL)
13235 {
13236 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13237 return -A_EFAULT;
13238 }
13239
13240 if (pPcmInfo->u8ConnectFlag == FALSE)
13241 {
13242 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13243 return -A_EPERM;
13244 }
13245
13246 switch(u32Cmd)
13247 {
13248 case AUDIO_PCM_CMD_NONBLOCKING:
13249 {
13250 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13251
13252 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13253 {
13254 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13255 s32Ret = -A_EINVAL;
13256 break;
13257 }
13258
13259 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13260
13261 break;
13262 }
13263
13264 case AUDIO_PCM_CMD_MULTICH:
13265 {
13266 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13267
13268 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13269 {
13270 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13271 s32Ret = -A_EINVAL;
13272 break;
13273 }
13274
13275 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13276 {
13277 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13278 s32Ret = -A_EINVAL;
13279 break;
13280 }
13281
13282 pPcmInfo->u8MultiChFlag = FALSE;
13283
13284 break;
13285 }
13286
13287 case AUDIO_PCM_CMD_MIXING:
13288 {
13289 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13290
13291 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13292 {
13293 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13294 s32Ret = -A_EINVAL;
13295 break;
13296 }
13297
13298 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13299 {
13300 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13301 s32Ret = -A_EINVAL;
13302 break;
13303 }
13304
13305 pPcmInfo->u8MixingFlag = FALSE;
13306
13307 break;
13308 }
13309
13310 case AUDIO_PCM_CMD_MIXINGGROUP:
13311 {
13312 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13313
13314 pPcmInfo->u32MixingGroup = u32MixingGroup;
13315
13316 break;
13317 }
13318
13319 case AUDIO_PCM_CMD_BUFFERDURATION:
13320 {
13321 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
13322 s32Ret = -A_EPERM;
13323
13324 break;
13325 }
13326
13327 case AUDIO_PCM_CMD_CHANNEL:
13328 {
13329 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
13330 s32Ret = -A_EPERM;
13331
13332 break;
13333 }
13334
13335 case AUDIO_PCM_CMD_SAMPLERATE:
13336 {
13337 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
13338 s32Ret = -A_EPERM;
13339
13340 break;
13341 }
13342
13343 case AUDIO_PCM_CMD_BITWIDTH:
13344 {
13345 MS_U32 u32BitWidth = *((MS_U32 *)pData);
13346
13347 pPcmInfo->u32BitWidth = u32BitWidth;
13348
13349 break;
13350 }
13351
13352 case AUDIO_PCM_CMD_BIGENDIAN:
13353 {
13354 MS_U32 u32BigEndian = *((MS_U32 *)pData);
13355
13356 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
13357 {
13358 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
13359 return -A_EINVAL;
13360 }
13361
13362 pPcmInfo->u32BigEndian = u32BigEndian;
13363
13364 break;
13365 }
13366
13367 case AUDIO_PCM_CMD_TIMESTAMP:
13368 {
13369 MS_U32 u32Timestamp = *((MS_U32 *)pData);
13370
13371 pPcmInfo->u32Timestamp = u32Timestamp;
13372
13373 break;
13374 }
13375
13376 case AUDIO_PCM_CMD_WEIGHTING:
13377 {
13378 MS_U32 u32Weighting = *((MS_U32 *)pData);
13379
13380 if (u32Weighting > 100)
13381 {
13382 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
13383 return -A_EINVAL;
13384 }
13385
13386 pPcmInfo->u32Weighting = u32Weighting;
13387
13388 break;
13389 }
13390
13391 case AUDIO_PCM_CMD_VOLUME:
13392 {
13393 MS_U32 u32Volume = *((MS_U32 *)pData);
13394
13395 if (u32Volume > 100)
13396 {
13397 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
13398 return -A_EINVAL;
13399 }
13400
13401 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
13402
13403 break;
13404 }
13405
13406 case AUDIO_PCM_CMD_MUTE:
13407 {
13408 MS_U32 u32Mute = *((MS_U32*)pData);
13409
13410 if (u32Mute == TRUE)
13411 {
13412 pPcmInfo->u32Volume |= 0x80000000;
13413 }
13414 else if (u32Mute == FALSE)
13415 {
13416 pPcmInfo->u32Volume &= 0x7FFFFFFF;
13417 }
13418 else
13419 {
13420 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
13421 s32Ret = -A_EINVAL;
13422 }
13423 break;
13424 }
13425
13426 default:
13427 {
13428 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13429 break;
13430 }
13431 }
13432
13433 return s32Ret;
13434 }
13435
HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd,void * pData)13436 MS_S32 HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd, void *pData)
13437 {
13438 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13439 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13440 MS_S32 s32Ret = 0;
13441 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13442
13443 if (pData == NULL)
13444 {
13445 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13446 return -A_EFAULT;
13447 }
13448
13449 if (pPcmInfo->u8ConnectFlag == FALSE)
13450 {
13451 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13452 return -A_EPERM;
13453 }
13454
13455 switch(u32Cmd)
13456 {
13457 case AUDIO_PCM_CMD_ALL:
13458 {
13459 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13460 MS_U32 u32MinSize = 0;
13461
13462 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13463 {
13464 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13465 s32Ret = -A_EINVAL;
13466 break;
13467 }
13468 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
13469 {
13470 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13471 }
13472
13473 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
13474 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
13475 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
13476
13477 break;
13478 }
13479
13480 case AUDIO_PCM_CMD_NONBLOCKING:
13481 {
13482 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
13483 break;
13484 }
13485
13486 case AUDIO_PCM_CMD_MULTICH:
13487 {
13488 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
13489 break;
13490 }
13491
13492 case AUDIO_PCM_CMD_MIXING:
13493 {
13494 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
13495 break;
13496 }
13497
13498 case AUDIO_PCM_CMD_MIXINGGROUP:
13499 {
13500 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
13501 break;
13502 }
13503
13504 case AUDIO_PCM_CMD_BUFFER:
13505 {
13506 /*
13507 * TODO, need better coding
13508 *
13509 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
13510 */
13511 break;
13512 }
13513
13514 case AUDIO_PCM_CMD_BUFFERDURATION:
13515 {
13516 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
13517 break;
13518 }
13519
13520 case AUDIO_PCM_CMD_READPTR:
13521 {
13522 /*
13523 * TODO, need better coding
13524 *
13525 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
13526 */
13527 break;
13528 }
13529
13530 case AUDIO_PCM_CMD_WRITEPTR:
13531 {
13532 /*
13533 * TODO, need better coding
13534 *
13535 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
13536 */
13537 break;
13538 }
13539
13540 case AUDIO_PCM_CMD_CHANNEL:
13541 {
13542 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
13543 break;
13544 }
13545
13546 case AUDIO_PCM_CMD_SAMPLERATE:
13547 {
13548 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
13549 break;
13550 }
13551
13552 case AUDIO_PCM_CMD_BITWIDTH:
13553 {
13554 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
13555 break;
13556 }
13557
13558 case AUDIO_PCM_CMD_BIGENDIAN:
13559 {
13560 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
13561 break;
13562 }
13563
13564 case AUDIO_PCM_CMD_TIMESTAMP:
13565 {
13566 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
13567 break;
13568 }
13569
13570 case AUDIO_PCM_CMD_WEIGHTING:
13571 {
13572 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
13573 break;
13574 }
13575
13576 case AUDIO_PCM_CMD_VOLUME:
13577 {
13578 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
13579 break;
13580 }
13581
13582 case AUDIO_PCM_CMD_BUFFERLEVEL:
13583 {
13584 MS_U32 u32WritePtrOffset = 0;
13585 MS_U32 u32BufferSize = 0;
13586 MS_S32 s32PcmLevel = 0;
13587
13588 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13589 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
13590
13591 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
13592 if (s32PcmLevel < 0)
13593 {
13594 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13595 s32PcmLevel += u32BufferSize;
13596 }
13597
13598 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
13599 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
13600
13601 break;
13602 }
13603
13604 case AUDIO_PCM_CMD_MUTE:
13605 {
13606 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
13607 break;
13608 }
13609
13610 case AUDIO_PCM_CMD_BUFFERSIZE:
13611 {
13612 *((MS_U32 *)pData) = PCM_CAPTURE1_BUF_SIZE;
13613
13614 break;
13615 }
13616
13617 default:
13618 {
13619 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13620 break;
13621 }
13622 }
13623
13624 return s32Ret;
13625 }
13626
HAL_AUDIO_PCM_Capture1_Read(void * pBuf,MS_U32 u32Size)13627 MS_U32 HAL_AUDIO_PCM_Capture1_Read(void *pBuf, MS_U32 u32Size)
13628 {
13629 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13630 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13631 MS_S8 *pBufTmp = NULL;
13632 MS_U32 u32BufferSize = 0;
13633 MS_U32 u32PcmLevel = 0;
13634 MS_U32 u32RequestSize = 0;
13635 MS_U32 u32RequestSizeTmp = 0;
13636 MS_U32 u32SizeToCopy = 0;
13637 MS_U32 u32RptrOffset = 0;
13638 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
13639
13640 if (pBuf == NULL)
13641 {
13642 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
13643 return 0;
13644 }
13645
13646 if (u32Size == 0)
13647 {
13648 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
13649 return 0;
13650 }
13651
13652 if (pPcmInfo->u8ConnectFlag == FALSE)
13653 {
13654 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13655 return 0;
13656 }
13657
13658 if (pPcmInfo->u8StartFlag == FALSE)
13659 {
13660 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
13661 return 0;
13662 }
13663
13664 pBufTmp = (MS_S8 *)pBuf;
13665
13666 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13667 HAL_AUDIO_PCM_Capture1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
13668 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE1_BUF_UNIT))
13669 {
13670 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
13671
13672 u32PcmLevel = 0;
13673 HAL_AUDIO_PCM_Capture1_Stop();
13674 HAL_AUDIO_PCM_Capture1_Restart();
13675 HAL_AUDIO_PCM_Capture1_Start();
13676 }
13677
13678 u32RequestSize = u32Size;
13679 u32RequestSizeTmp = u32RequestSize;
13680
13681 /* copy data from PCM buffer */
13682 if (u32PcmLevel >= u32RequestSize)
13683 {
13684 do {
13685 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
13686 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
13687
13688 #ifdef MSOS_TYPE_LINUX_KERNEL
13689 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
13690 #else
13691 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
13692 #endif
13693
13694 pBufTmp += u32SizeToCopy;
13695 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
13696 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13697 {
13698 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13699 {
13700 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
13701 }
13702 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13703 }
13704
13705 u32RequestSizeTmp -= u32SizeToCopy;
13706 } while (u32RequestSizeTmp > 0);
13707
13708 /* flush MIU */
13709 MsOS_FlushMemory();
13710
13711 /* update read pointer to engine */
13712 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
13713 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
13714
13715 return u32Size;
13716 }
13717
13718 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
13719
13720 return 0;
13721 }
13722
HAL_AUDIO_PCM_Capture1_Flush(void)13723 MS_S32 HAL_AUDIO_PCM_Capture1_Flush(void)
13724 {
13725 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13726 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13727 MS_S32 s32Ret = 0;
13728 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13729
13730 if (pPcmInfo->u8StartFlag == FALSE)
13731 {
13732 HAL_AUDIO_PCM_Capture1_Restart();
13733 HAL_AUDIO_PCM_Capture1_Stop();
13734 }
13735
13736 return s32Ret;
13737 }
13738 #endif
13739
13740 #if AUDIO_PCM_CAPTURE2_SUPPORT
HAL_AUDIO_PCM_Capture2_Restart(void)13741 MS_S32 HAL_AUDIO_PCM_Capture2_Restart(void)
13742 {
13743 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13744 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13745 MS_U32 u32WritePtrOffset = 0;
13746 MS_U32 u32TimeoutCounter = 0;
13747 MS_S32 s32Ret = 0;
13748
13749 if (pPcmInfo->u8ConnectFlag == FALSE)
13750 {
13751 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13752 return -A_EPERM;
13753 }
13754
13755 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0x0000);
13756
13757 do {
13758 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13759
13760 if (u32WritePtrOffset != 0)
13761 {
13762 #ifdef MSOS_TYPE_LINUX_KERNEL
13763 udelay(50);
13764 #else
13765 AUDIO_DELAY1US(50);
13766 #endif
13767 u32TimeoutCounter++;
13768 }
13769 else
13770 {
13771 break;
13772 }
13773 } while (u32TimeoutCounter < 10000);
13774
13775 /* clear PCM buffer */
13776 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE2_BUF_SIZE);
13777
13778 /* flush MIU */
13779 MsOS_FlushMemory();
13780
13781 /* reset PCM capture1 read & write pointer */
13782 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13783 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13784 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0x0000);
13785
13786 return s32Ret;
13787 }
13788
HAL_AUDIO_PCM_Capture2_Open(void * pData)13789 MS_S32 HAL_AUDIO_PCM_Capture2_Open(void *pData)
13790 {
13791 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13792 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13793 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13794 MS_U32 u32TargetBufferAddrPa = 0;
13795 MS_S32 s32Ret = 0;
13796 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13797
13798 if (pData == NULL)
13799 {
13800 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13801 return -A_EFAULT;
13802 }
13803
13804 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13805
13806 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13807 {
13808 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13809 return -A_EINVAL;
13810 }
13811
13812 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13813 {
13814 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
13815 return -A_EINVAL;
13816 }
13817
13818 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13819 {
13820 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13821 return -A_EINVAL;
13822 }
13823
13824 if (pUserPcmInfo->u8MixingFlag == TRUE)
13825 {
13826 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13827 return -A_EINVAL;
13828 }
13829
13830 if (pUserPcmInfo->u8CaptureFlag != TRUE)
13831 {
13832 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
13833 return -A_EINVAL;
13834 }
13835
13836 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
13837 {
13838 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13839 return -A_EINVAL;
13840 }
13841
13842 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
13843 {
13844 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13845 return -A_EINVAL;
13846 }
13847
13848 /* fill in settings */
13849 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13850 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13851 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13852 pPcmInfo->u8ConnectFlag = TRUE;
13853 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13854 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13855 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13856 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13857 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13858 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE2_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
13859 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
13860 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
13861 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13862 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13863 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13864 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13865
13866 /* init PCM buffer address */
13867 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
13868 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13869 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13870 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13871
13872 /* restart */
13873 HAL_AUDIO_PCM_Capture2_Restart();
13874
13875 return s32Ret;
13876 }
13877
HAL_AUDIO_PCM_Capture2_Close(void)13878 MS_S32 HAL_AUDIO_PCM_Capture2_Close(void)
13879 {
13880 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13881 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13882 MS_S32 s32Ret = 0;
13883 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13884
13885 if (pPcmInfo->u8ConnectFlag != FALSE)
13886 {
13887 HAL_AUDIO_PCM_Capture2_Flush();
13888 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13889 }
13890
13891 return s32Ret;
13892 }
13893
HAL_AUDIO_PCM_Capture2_Start(void)13894 MS_S32 HAL_AUDIO_PCM_Capture2_Start(void)
13895 {
13896 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13897 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13898 MS_U32 u32BufferSize = 0;
13899 MS_S32 s32Ret = 0;
13900 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13901
13902 if (pPcmInfo->u8StartFlag == FALSE)
13903 {
13904 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13905 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
13906
13907 pPcmInfo->u8StartFlag = TRUE;
13908 }
13909
13910 return s32Ret;
13911 }
13912
HAL_AUDIO_PCM_Capture2_Stop(void)13913 MS_S32 HAL_AUDIO_PCM_Capture2_Stop(void)
13914 {
13915 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13916 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13917 MS_S32 s32Ret = 0;
13918 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13919
13920 if (pPcmInfo->u8StartFlag != FALSE)
13921 {
13922 /* TODO, there is no such control in DSP */
13923
13924 pPcmInfo->u8StartFlag = FALSE;
13925 }
13926
13927 return s32Ret;
13928 }
13929
HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd,const void * pData)13930 MS_S32 HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd, const void *pData)
13931 {
13932 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13933 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13934 MS_S32 s32Ret = 0;
13935 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13936
13937 if (pData == NULL)
13938 {
13939 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13940 return -A_EFAULT;
13941 }
13942
13943 if (pPcmInfo->u8ConnectFlag == FALSE)
13944 {
13945 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13946 return -A_EPERM;
13947 }
13948
13949 switch(u32Cmd)
13950 {
13951 case AUDIO_PCM_CMD_NONBLOCKING:
13952 {
13953 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13954
13955 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13956 {
13957 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13958 s32Ret = -A_EINVAL;
13959 break;
13960 }
13961
13962 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13963
13964 break;
13965 }
13966
13967 case AUDIO_PCM_CMD_MULTICH:
13968 {
13969 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13970
13971 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13972 {
13973 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13974 s32Ret = -A_EINVAL;
13975 break;
13976 }
13977
13978 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13979 {
13980 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13981 s32Ret = -A_EINVAL;
13982 break;
13983 }
13984
13985 pPcmInfo->u8MultiChFlag = FALSE;
13986
13987 break;
13988 }
13989
13990 case AUDIO_PCM_CMD_MIXING:
13991 {
13992 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13993
13994 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13995 {
13996 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13997 s32Ret = -A_EINVAL;
13998 break;
13999 }
14000
14001 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
14002 {
14003 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14004 s32Ret = -A_EINVAL;
14005 break;
14006 }
14007
14008 pPcmInfo->u8MixingFlag = FALSE;
14009
14010 break;
14011 }
14012
14013 case AUDIO_PCM_CMD_MIXINGGROUP:
14014 {
14015 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
14016
14017 pPcmInfo->u32MixingGroup = u32MixingGroup;
14018
14019 break;
14020 }
14021
14022 case AUDIO_PCM_CMD_BUFFERDURATION:
14023 {
14024 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
14025 s32Ret = -A_EPERM;
14026
14027 break;
14028 }
14029
14030 case AUDIO_PCM_CMD_CHANNEL:
14031 {
14032 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14033 s32Ret = -A_EPERM;
14034
14035 break;
14036 }
14037
14038 case AUDIO_PCM_CMD_SAMPLERATE:
14039 {
14040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14041 s32Ret = -A_EPERM;
14042
14043 break;
14044 }
14045
14046 case AUDIO_PCM_CMD_BITWIDTH:
14047 {
14048 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14049
14050 pPcmInfo->u32BitWidth = u32BitWidth;
14051
14052 break;
14053 }
14054
14055 case AUDIO_PCM_CMD_BIGENDIAN:
14056 {
14057 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14058
14059 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14060 {
14061 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
14062 return -A_EINVAL;
14063 }
14064
14065 pPcmInfo->u32BigEndian = u32BigEndian;
14066
14067 break;
14068 }
14069
14070 case AUDIO_PCM_CMD_TIMESTAMP:
14071 {
14072 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14073
14074 pPcmInfo->u32Timestamp = u32Timestamp;
14075
14076 break;
14077 }
14078
14079 case AUDIO_PCM_CMD_WEIGHTING:
14080 {
14081 MS_U32 u32Weighting = *((MS_U32 *)pData);
14082
14083 if (u32Weighting > 100)
14084 {
14085 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14086 return -A_EINVAL;
14087 }
14088
14089 pPcmInfo->u32Weighting = u32Weighting;
14090
14091 break;
14092 }
14093
14094 case AUDIO_PCM_CMD_VOLUME:
14095 {
14096 MS_U32 u32Volume = *((MS_U32 *)pData);
14097
14098 if (u32Volume > 100)
14099 {
14100 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14101 return -A_EINVAL;
14102 }
14103
14104 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14105
14106 break;
14107 }
14108
14109 case AUDIO_PCM_CMD_MUTE:
14110 {
14111 MS_U32 u32Mute = *((MS_U32*)pData);
14112
14113 if (u32Mute == TRUE)
14114 {
14115 pPcmInfo->u32Volume |= 0x80000000;
14116 }
14117 else if (u32Mute == FALSE)
14118 {
14119 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14120 }
14121 else
14122 {
14123 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
14124 s32Ret = -A_EINVAL;
14125 }
14126 break;
14127 }
14128
14129 default:
14130 {
14131 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14132 break;
14133 }
14134 }
14135
14136 return s32Ret;
14137 }
14138
HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd,void * pData)14139 MS_S32 HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd, void *pData)
14140 {
14141 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14142 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14143 MS_S32 s32Ret = 0;
14144 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14145
14146 if (pData == NULL)
14147 {
14148 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14149 return -A_EFAULT;
14150 }
14151
14152 if (pPcmInfo->u8ConnectFlag == FALSE)
14153 {
14154 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14155 return -A_EPERM;
14156 }
14157
14158 switch(u32Cmd)
14159 {
14160 case AUDIO_PCM_CMD_ALL:
14161 {
14162 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14163 MS_U32 u32MinSize = 0;
14164
14165 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14166 {
14167 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14168 s32Ret = -A_EINVAL;
14169 break;
14170 }
14171 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14172 {
14173 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14174 }
14175
14176 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14177 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14178 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14179
14180 break;
14181 }
14182
14183 case AUDIO_PCM_CMD_NONBLOCKING:
14184 {
14185 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14186 break;
14187 }
14188
14189 case AUDIO_PCM_CMD_MULTICH:
14190 {
14191 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14192 break;
14193 }
14194
14195 case AUDIO_PCM_CMD_MIXING:
14196 {
14197 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14198 break;
14199 }
14200
14201 case AUDIO_PCM_CMD_MIXINGGROUP:
14202 {
14203 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14204 break;
14205 }
14206
14207 case AUDIO_PCM_CMD_BUFFER:
14208 {
14209 /*
14210 * TODO, need better coding
14211 *
14212 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14213 */
14214 break;
14215 }
14216
14217 case AUDIO_PCM_CMD_BUFFERDURATION:
14218 {
14219 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14220 break;
14221 }
14222
14223 case AUDIO_PCM_CMD_READPTR:
14224 {
14225 /*
14226 * TODO, need better coding
14227 *
14228 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14229 */
14230 break;
14231 }
14232
14233 case AUDIO_PCM_CMD_WRITEPTR:
14234 {
14235 /*
14236 * TODO, need better coding
14237 *
14238 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14239 */
14240 break;
14241 }
14242
14243 case AUDIO_PCM_CMD_CHANNEL:
14244 {
14245 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14246 break;
14247 }
14248
14249 case AUDIO_PCM_CMD_SAMPLERATE:
14250 {
14251 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14252 break;
14253 }
14254
14255 case AUDIO_PCM_CMD_BITWIDTH:
14256 {
14257 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14258 break;
14259 }
14260
14261 case AUDIO_PCM_CMD_BIGENDIAN:
14262 {
14263 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14264 break;
14265 }
14266
14267 case AUDIO_PCM_CMD_TIMESTAMP:
14268 {
14269 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14270 break;
14271 }
14272
14273 case AUDIO_PCM_CMD_WEIGHTING:
14274 {
14275 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14276 break;
14277 }
14278
14279 case AUDIO_PCM_CMD_VOLUME:
14280 {
14281 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14282 break;
14283 }
14284
14285 case AUDIO_PCM_CMD_BUFFERLEVEL:
14286 {
14287 MS_U32 u32WritePtrOffset = 0;
14288 MS_U32 u32BufferSize = 0;
14289 MS_S32 s32PcmLevel = 0;
14290
14291 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14292 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
14293
14294 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
14295 if (s32PcmLevel < 0)
14296 {
14297 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14298 s32PcmLevel += u32BufferSize;
14299 }
14300
14301 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
14302 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
14303
14304 break;
14305 }
14306
14307 case AUDIO_PCM_CMD_MUTE:
14308 {
14309 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
14310 break;
14311 }
14312
14313 case AUDIO_PCM_CMD_BUFFERSIZE:
14314 {
14315 *((MS_U32 *)pData) = PCM_CAPTURE2_BUF_SIZE;
14316
14317 break;
14318 }
14319
14320 default:
14321 {
14322 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14323 break;
14324 }
14325 }
14326
14327 return s32Ret;
14328 }
14329
HAL_AUDIO_PCM_Capture2_Read(void * pBuf,MS_U32 u32Size)14330 MS_U32 HAL_AUDIO_PCM_Capture2_Read(void *pBuf, MS_U32 u32Size)
14331 {
14332 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14333 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14334 MS_S8 *pBufTmp = NULL;
14335 MS_U32 u32BufferSize = 0;
14336 MS_U32 u32PcmLevel = 0;
14337 MS_U32 u32RequestSize = 0;
14338 MS_U32 u32RequestSizeTmp = 0;
14339 MS_U32 u32SizeToCopy = 0;
14340 MS_U32 u32RptrOffset = 0;
14341 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14342
14343 if (pBuf == NULL)
14344 {
14345 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14346 return 0;
14347 }
14348
14349 if (u32Size == 0)
14350 {
14351 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14352 return 0;
14353 }
14354
14355 if (pPcmInfo->u8ConnectFlag == FALSE)
14356 {
14357 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14358 return 0;
14359 }
14360
14361 if (pPcmInfo->u8StartFlag == FALSE)
14362 {
14363 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
14364 return 0;
14365 }
14366
14367 pBufTmp = (MS_S8 *)pBuf;
14368
14369 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14370 HAL_AUDIO_PCM_Capture2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14371 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE2_BUF_UNIT))
14372 {
14373 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
14374
14375 u32PcmLevel = 0;
14376 HAL_AUDIO_PCM_Capture2_Stop();
14377 HAL_AUDIO_PCM_Capture2_Restart();
14378 HAL_AUDIO_PCM_Capture2_Start();
14379 }
14380
14381 u32RequestSize = u32Size;
14382 u32RequestSizeTmp = u32RequestSize;
14383
14384 /* copy data from PCM buffer */
14385 if (u32PcmLevel >= u32RequestSize)
14386 {
14387 do {
14388 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
14389 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14390
14391 #ifdef MSOS_TYPE_LINUX_KERNEL
14392 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14393 #else
14394 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14395 #endif
14396
14397 pBufTmp += u32SizeToCopy;
14398 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
14399 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14400 {
14401 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14402 {
14403 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14404 }
14405 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14406 }
14407
14408 u32RequestSizeTmp -= u32SizeToCopy;
14409 } while (u32RequestSizeTmp > 0);
14410
14411 /* flush MIU */
14412 MsOS_FlushMemory();
14413
14414 /* update read pointer to engine */
14415 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
14416 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
14417
14418 return u32Size;
14419 }
14420
14421 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14422
14423 return 0;
14424 }
14425
HAL_AUDIO_PCM_Capture2_Flush(void)14426 MS_S32 HAL_AUDIO_PCM_Capture2_Flush(void)
14427 {
14428 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14429 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14430 MS_S32 s32Ret = 0;
14431 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14432
14433 if (pPcmInfo->u8StartFlag == FALSE)
14434 {
14435 HAL_AUDIO_PCM_Capture2_Restart();
14436 HAL_AUDIO_PCM_Capture2_Stop();
14437 }
14438
14439 return s32Ret;
14440 }
14441 #endif
14442
14443 #if AUDIO_HW_DMA_WRITER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)14444 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)
14445 {
14446 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14447 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14448 //MS_U32 u32WritePtrOffset = 0;
14449 //MS_U32 u32TimeoutCounter = 0;
14450 MS_S32 s32Ret = 0;
14451
14452 if (pPcmInfo->u8ConnectFlag == FALSE)
14453 {
14454 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14455 return -A_EPERM;
14456 }
14457
14458 /* clear PCM buffer */
14459 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_WTR1_BUF_SIZE);
14460
14461 /* flush MIU */
14462 MsOS_FlushMemory();
14463 return s32Ret;
14464 }
14465
HAL_AUDIO_PCM_HwDma_Writer1_Open(void * pData)14466 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Open(void *pData)
14467 {
14468 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14469 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14470 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
14471 MS_U32 u32TargetBufferAddrPa = 0;
14472 MS_U32 u32TargetBufferSize = 0;
14473 MS_U32 u32TargetChannel = 0;
14474 MS_U32 u32TargetBitWidth = 0;
14475 MS_U32 u32TargetAlignmentSize = 0;
14476 MS_S32 s32Ret = 0;
14477 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
14478
14479 if (pData == NULL)
14480 {
14481 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14482 return -A_EFAULT;
14483 }
14484
14485 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14486
14487 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14488 {
14489 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14490 return -A_EINVAL;
14491 }
14492
14493 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
14494 {
14495 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
14496 return -A_EINVAL;
14497 }
14498
14499 if (pUserPcmInfo->u8MultiChFlag == TRUE)
14500 {
14501 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14502 return -A_EINVAL;
14503 }
14504
14505 if (pUserPcmInfo->u8MixingFlag == TRUE)
14506 {
14507 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14508 return -A_EINVAL;
14509 }
14510
14511 if (pUserPcmInfo->u8CaptureFlag != TRUE)
14512 {
14513 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
14514 return -A_EINVAL;
14515 }
14516
14517 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
14518 {
14519 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
14520 return -A_EINVAL;
14521 }
14522
14523 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(pUserPcmInfo->u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
14524 {
14525 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
14526 return -A_EINVAL;
14527 }
14528
14529 /* fill in settings */
14530 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14531 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
14532 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
14533 pPcmInfo->u8ConnectFlag = TRUE;
14534 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14535 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14536
14537 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
14538 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
14539 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
14540 pPcmInfo->u32BufferDuration = ((HW_DMA_WTR1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
14541 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
14542 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;;
14543 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
14544 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
14545 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
14546 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
14547
14548 /* init PCM buffer address */
14549 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR;
14550 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
14551 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14552 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14553
14554 /* set PCM buffer address */
14555 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
14556 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE) & 0xFFFF);
14557 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
14558
14559 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x80, 0x80);
14560 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x0F, M2S_MBOX_GET_Raw);
14561
14562 /* calculate buffer size */
14563 u32TargetChannel = 2;
14564 u32TargetBitWidth = 16;
14565 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
14566 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
14567 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
14568 if (u32TargetBufferSize > HW_DMA_WTR1_BUF_SIZE)
14569 {
14570 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pPcmInfo->u32BufferDuration, (unsigned int)pPcmInfo->u32SampleRate);
14571 u32TargetBufferSize = HW_DMA_WTR1_BUF_SIZE;
14572 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
14573 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
14574 }
14575
14576 /* set buffer size */
14577 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
14578 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
14579
14580 /* Reset and Start DMA Writer */
14581 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
14582 AUDIO_DELAY1US(1);
14583 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
14584
14585 /* restart */
14586 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
14587
14588 return s32Ret;
14589 }
14590
HAL_AUDIO_PCM_HwDma_Writer1_Close(void)14591 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Close(void)
14592 {
14593 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14594 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14595 MS_S32 s32Ret = 0;
14596 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
14597
14598 if (pPcmInfo->u8ConnectFlag != FALSE)
14599 {
14600 HAL_AUDIO_PCM_HwDma_Writer1_Flush();
14601 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14602 }
14603
14604 return s32Ret;
14605 }
14606
HAL_AUDIO_PCM_HwDma_Writer1_Start(void)14607 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Start(void)
14608 {
14609 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14610 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14611 //MS_U32 u32BufferSize = 0;
14612 MS_S32 s32Ret = 0;
14613 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
14614
14615 if (pPcmInfo->u8StartFlag == FALSE)
14616 {
14617 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0001);
14618 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0002);
14619
14620 pPcmInfo->u8StartFlag = TRUE;
14621 }
14622
14623 return s32Ret;
14624 }
14625
HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)14626 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)
14627 {
14628 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14629 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14630 MS_S32 s32Ret = 0;
14631 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
14632
14633 if (pPcmInfo->u8StartFlag != FALSE)
14634 {
14635 /* TODO, there is no such control in DSP */
14636
14637 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0000);
14638 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0000);
14639
14640 pPcmInfo->u8StartFlag = FALSE;
14641 }
14642
14643 return s32Ret;
14644 }
14645
HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd,const void * pData)14646 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd, const void *pData)
14647 {
14648 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14649 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14650 MS_S32 s32Ret = 0;
14651 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14652
14653 if (pData == NULL)
14654 {
14655 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14656 return -A_EFAULT;
14657 }
14658
14659 if (pPcmInfo->u8ConnectFlag == FALSE)
14660 {
14661 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14662 return -A_EPERM;
14663 }
14664
14665 switch(u32Cmd)
14666 {
14667 case AUDIO_PCM_CMD_NONBLOCKING:
14668 {
14669 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
14670
14671 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
14672 {
14673 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
14674 s32Ret = -A_EINVAL;
14675 break;
14676 }
14677
14678 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
14679
14680 break;
14681 }
14682
14683 case AUDIO_PCM_CMD_MULTICH:
14684 {
14685 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
14686
14687 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
14688 {
14689 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
14690 s32Ret = -A_EINVAL;
14691 break;
14692 }
14693
14694 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
14695 {
14696 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14697 s32Ret = -A_EINVAL;
14698 break;
14699 }
14700
14701 pPcmInfo->u8MultiChFlag = FALSE;
14702
14703 break;
14704 }
14705
14706 case AUDIO_PCM_CMD_MIXING:
14707 {
14708 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
14709
14710 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
14711 {
14712 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
14713 s32Ret = -A_EINVAL;
14714 break;
14715 }
14716
14717 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
14718 {
14719 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14720 s32Ret = -A_EINVAL;
14721 break;
14722 }
14723
14724 pPcmInfo->u8MixingFlag = FALSE;
14725
14726 break;
14727 }
14728
14729 case AUDIO_PCM_CMD_MIXINGGROUP:
14730 {
14731 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
14732
14733 pPcmInfo->u32MixingGroup = u32MixingGroup;
14734
14735 break;
14736 }
14737
14738 case AUDIO_PCM_CMD_BUFFERDURATION:
14739 {
14740 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
14741
14742 if (u32BufferDuration == 0)
14743 {
14744 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
14745 s32Ret = -A_EINVAL;
14746 break;
14747 }
14748
14749 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
14750 {
14751 pPcmInfo->u32BufferDuration = u32BufferDuration;
14752 pPCM->u8SettingChangeFlag = TRUE;
14753 }
14754
14755 break;
14756 }
14757
14758 case AUDIO_PCM_CMD_CHANNEL:
14759 {
14760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14761 s32Ret = -A_EPERM;
14762
14763 break;
14764 }
14765
14766 case AUDIO_PCM_CMD_SAMPLERATE:
14767 {
14768 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14769 s32Ret = -A_EPERM;
14770
14771 break;
14772 }
14773
14774 case AUDIO_PCM_CMD_BITWIDTH:
14775 {
14776 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14777
14778 pPcmInfo->u32BitWidth = u32BitWidth;
14779
14780 break;
14781 }
14782
14783 case AUDIO_PCM_CMD_BIGENDIAN:
14784 {
14785 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14786
14787 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14788 {
14789 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
14790 return -A_EINVAL;
14791 }
14792
14793 pPcmInfo->u32BigEndian = u32BigEndian;
14794
14795 break;
14796 }
14797
14798 case AUDIO_PCM_CMD_TIMESTAMP:
14799 {
14800 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14801
14802 pPcmInfo->u32Timestamp = u32Timestamp;
14803
14804 break;
14805 }
14806
14807 case AUDIO_PCM_CMD_WEIGHTING:
14808 {
14809 MS_U32 u32Weighting = *((MS_U32 *)pData);
14810
14811 if (u32Weighting > 100)
14812 {
14813 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14814 return -A_EINVAL;
14815 }
14816
14817 pPcmInfo->u32Weighting = u32Weighting;
14818
14819 break;
14820 }
14821
14822 case AUDIO_PCM_CMD_VOLUME:
14823 {
14824 MS_U32 u32Volume = *((MS_U32 *)pData);
14825
14826 if (u32Volume > 100)
14827 {
14828 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14829 return -A_EINVAL;
14830 }
14831
14832 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14833
14834 break;
14835 }
14836
14837 case AUDIO_PCM_CMD_MUTE:
14838 {
14839 MS_U32 u32Mute = *((MS_U32*)pData);
14840
14841 if (u32Mute == TRUE)
14842 {
14843 pPcmInfo->u32Volume |= 0x80000000;
14844 }
14845 else if (u32Mute == FALSE)
14846 {
14847 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14848 }
14849 else
14850 {
14851 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
14852 s32Ret = -A_EINVAL;
14853 }
14854 break;
14855 }
14856
14857 default:
14858 {
14859 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
14860 break;
14861 }
14862 }
14863
14864 return s32Ret;
14865 }
14866
HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd,void * pData)14867 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd, void *pData)
14868 {
14869 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14870 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14871 MS_S32 s32Ret = 0;
14872 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14873
14874 if (pData == NULL)
14875 {
14876 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14877 return -A_EFAULT;
14878 }
14879
14880 if (pPcmInfo->u8ConnectFlag == FALSE)
14881 {
14882 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14883 return -A_EPERM;
14884 }
14885
14886 switch(u32Cmd)
14887 {
14888 case AUDIO_PCM_CMD_ALL:
14889 {
14890 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14891 MS_U32 u32MinSize = 0;
14892
14893 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14894 {
14895 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14896 s32Ret = -A_EINVAL;
14897 break;
14898 }
14899 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14900 {
14901 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14902 }
14903
14904 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14905 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14906 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14907
14908 break;
14909 }
14910
14911 case AUDIO_PCM_CMD_NONBLOCKING:
14912 {
14913 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14914 break;
14915 }
14916
14917 case AUDIO_PCM_CMD_MULTICH:
14918 {
14919 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14920 break;
14921 }
14922
14923 case AUDIO_PCM_CMD_MIXING:
14924 {
14925 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14926 break;
14927 }
14928
14929 case AUDIO_PCM_CMD_MIXINGGROUP:
14930 {
14931 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14932 break;
14933 }
14934
14935 case AUDIO_PCM_CMD_BUFFER:
14936 {
14937 /*
14938 * TODO, need better coding
14939 *
14940 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14941 */
14942 break;
14943 }
14944
14945 case AUDIO_PCM_CMD_BUFFERDURATION:
14946 {
14947 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14948 break;
14949 }
14950
14951 case AUDIO_PCM_CMD_READPTR:
14952 {
14953 /*
14954 * TODO, need better coding
14955 *
14956 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14957 */
14958 break;
14959 }
14960
14961 case AUDIO_PCM_CMD_WRITEPTR:
14962 {
14963 /*
14964 * TODO, need better coding
14965 *
14966 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14967 */
14968 break;
14969 }
14970
14971 case AUDIO_PCM_CMD_CHANNEL:
14972 {
14973 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14974 break;
14975 }
14976
14977 case AUDIO_PCM_CMD_SAMPLERATE:
14978 {
14979 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14980 break;
14981 }
14982
14983 case AUDIO_PCM_CMD_BITWIDTH:
14984 {
14985 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14986 break;
14987 }
14988
14989 case AUDIO_PCM_CMD_BIGENDIAN:
14990 {
14991 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14992 break;
14993 }
14994
14995 case AUDIO_PCM_CMD_TIMESTAMP:
14996 {
14997 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14998 break;
14999 }
15000
15001 case AUDIO_PCM_CMD_WEIGHTING:
15002 {
15003 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
15004 break;
15005 }
15006
15007 case AUDIO_PCM_CMD_VOLUME:
15008 {
15009 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
15010 break;
15011 }
15012
15013 case AUDIO_PCM_CMD_BUFFERLEVEL:
15014 {
15015 MS_U32 u32BufferLevel1 = 0;
15016 MS_U32 u32BufferLevel2 = 0;
15017 MS_U32 u32Timeout = 20;
15018
15019 while (u32Timeout > 0)
15020 {
15021 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
15022 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
15023
15024 if (u32BufferLevel1 == u32BufferLevel2)
15025 {
15026 break;
15027 }
15028
15029 u32Timeout--;
15030
15031 #ifdef MSOS_TYPE_LINUX_KERNEL
15032 udelay(1);
15033 #else
15034 AUDIO_DELAY1US(1);
15035 #endif
15036 }
15037
15038 if (u32BufferLevel1 != u32BufferLevel2)
15039 {
15040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
15041 }
15042
15043 pPcmInfo->u32BufferLevel = u32BufferLevel2;
15044 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
15045
15046 break;
15047 }
15048
15049 case AUDIO_PCM_CMD_MUTE:
15050 {
15051 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
15052 break;
15053 }
15054
15055 case AUDIO_PCM_CMD_BUFFERSIZE:
15056 {
15057 *((MS_U32 *)pData) = HW_DMA_WTR1_BUF_SIZE;
15058
15059 break;
15060 }
15061
15062 default:
15063 {
15064 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
15065 break;
15066 }
15067 }
15068
15069 return s32Ret;
15070 }
15071
HAL_AUDIO_PCM_HwDma_Writer1_Read(void * pBuf,MS_U32 u32Size)15072 MS_U32 HAL_AUDIO_PCM_HwDma_Writer1_Read(void *pBuf, MS_U32 u32Size)
15073 {
15074 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15075 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15076 MS_S8 *pBufTmp = NULL;
15077 MS_U32 u32BufferSize = 0;
15078 MS_U32 u32PcmLevel = 0;
15079 MS_U32 u32RequestSize = 0;
15080 MS_U32 u32RequestSizeTmp = 0;
15081 MS_U32 u32SizeToCopy = 0;
15082 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
15083
15084 if (pBuf == NULL)
15085 {
15086 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
15087 return 0;
15088 }
15089
15090 if (u32Size == 0)
15091 {
15092 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
15093 return 0;
15094 }
15095
15096 if (pPcmInfo->u8ConnectFlag == FALSE)
15097 {
15098 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15099 return 0;
15100 }
15101
15102 if (pPcmInfo->u8StartFlag == FALSE)
15103 {
15104 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
15105 return 0;
15106 }
15107
15108 pBufTmp = (MS_S8 *)pBuf;
15109
15110 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15111 HAL_AUDIO_PCM_HwDma_Writer1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
15112
15113 u32RequestSize = u32Size;
15114 u32RequestSizeTmp = u32RequestSize;
15115
15116 /* copy data from PCM buffer */
15117 if (u32PcmLevel >= u32RequestSize)
15118 {
15119 do {
15120 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
15121 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
15122
15123 #ifdef MSOS_TYPE_LINUX_KERNEL
15124 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15125 #else
15126 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15127 #endif
15128
15129 pBufTmp += u32SizeToCopy;
15130 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
15131 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15132 {
15133 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15134 {
15135 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
15136 }
15137 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15138 }
15139
15140 u32RequestSizeTmp -= u32SizeToCopy;
15141 } while (u32RequestSizeTmp > 0);
15142
15143 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
15144 HAL_AUR2_WriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
15145 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
15146
15147 return u32Size;
15148 }
15149 return 0;
15150 }
15151
HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)15152 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)
15153 {
15154 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15155 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15156 MS_S32 s32Ret = 0;
15157 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
15158
15159 if (pPcmInfo->u8StartFlag == FALSE)
15160 {
15161 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
15162 HAL_AUDIO_PCM_HwDma_Writer1_Stop();
15163 }
15164
15165 return s32Ret;
15166 }
15167 #endif
15168
HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)15169 void HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)
15170 {
15171 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_ipSecurity, ip_auth);
15172 }
15173
15174 ////////////////////////////////////////////////////////////////////////////////
15175 /// @brief \b Function \b Name: HAL_AUDIO_Set_DecimationMode()
15176 /// @brief \b Function \b Description: HAL_AUDIO_Set_Decimation register
15177 /// @param <IN> \b AUDIO_OUTPUT_TYPE Output_Type: Audio Output type
15178 /// @param <IN> \b MS_BOOL Enable : Audio ID: ADEC ID
15179 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type,Audio_id ID)15180 void HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type, Audio_id ID)
15181 {
15182 AUDIO_DEC_ID DecID = AU_DEC_ID1;
15183
15184 if(ID == ADEC1)
15185 {
15186 DecID = AU_DEC_ID1;
15187 }
15188 else if(ID == ADEC2)
15189 {
15190 DecID = AU_DEC_ID3;
15191 }
15192 else
15193 {
15194 DecID = AU_DEC_ID1;
15195 }
15196
15197 switch(Output_Type)
15198 {
15199 case AUDIO_HDMI_OUTPUT: //high rate nonPCM application need decimation
15200 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, DecID) > 48000) &&
15201 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20))
15202 {
15203 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x04);
15204 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x10);
15205 }
15206 else
15207 {
15208 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x00);
15209 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x00);
15210 }
15211 break;
15212
15213 case AUDIO_HDMI_ARC_OUTPUT:
15214 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, DecID) > 48000) &&
15215 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
15216 {
15217 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x02);
15218 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x08);
15219 }
15220 else
15221 {
15222 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x00);
15223 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x00);
15224 }
15225 break;
15226
15227 case AUDIO_SPDIF_OUTPUT:
15228 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, DecID) > 48000) &&
15229 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
15230 {
15231 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x01);
15232 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x04);
15233 }
15234 else
15235 {
15236 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x00);
15237 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x00);
15238 }
15239 break;
15240
15241 default:
15242 break;
15243 }
15244 }
15245
15246 ////////////////////////////////////////////////////////////////////////////////
15247 /// @brief \b Function \b Name: HAL_AUDIO_CheckPlayDone()
15248 /// @brief \b Function \b Description: Check file play done. If file play done, will return TRUE
15249 /// @param <IN> \b NONE :
15250 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
15251 /// @param <GLOBAL> \b NONE :
15252 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckPlayDone(void)15253 MS_BOOL HAL_AUDIO_CheckPlayDone(void)
15254 {
15255 if (((HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_okFrmCnt) != 0) ||
15256 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_errFrmCnt) != 0)) &&
15257 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_pcmBuf_currLevel) < AUD_R2_DMA_BURST_BYTES))
15258 {
15259 CheckPlayDoneCnt = CheckPlayDoneCnt + 1;
15260
15261 if (CheckPlayDoneCnt == 3)
15262 {
15263 CheckPlayDoneCnt = 0;
15264 return TRUE;
15265 }
15266 return FALSE;
15267 }
15268 else
15269 {
15270 CheckPlayDoneCnt = 0;
15271 return FALSE;
15272 }
15273 }
15274
15275 ////////////////////////////////////////////////////////////////////////////////
15276 /// @brief \b Function \b Name: HAL_AUDIO_CheckVersionInfo()
15277 /// @brief \b Function \b Description: Check Version info
15278 /// @param <IN> \b NONE :
15279 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
15280 /// @param <GLOBAL> \b NONE :
15281 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckVersionInfo(void)15282 MS_BOOL HAL_AUDIO_CheckVersionInfo(void)
15283 {
15284 HALAUDIO_PRINT("\r\n \033[1;32m==========Audio R2 & DSP Version Check==================\033[0m");
15285 HALAUDIO_PRINT("\r\n \033[1;32m DEC-R2:0x%06X DSP System:0x%06X \033[0m \r\n", DEC_R2_VERSION, system_version_num);
15286
15287 if(HAL_AUDIO_AbsReadReg(REG_DECR2_VERSION) != DEC_R2_VERSION) // Compare DEC R2 Version with Mail Box
15288 {
15289 HALAUDIO_PRINT("\r\n \033[1;32m Audio DEC-R2 Version Mismatch!!!!!!! \033[0m \r\n");
15290 }
15291 return TRUE;
15292 }
15293
15294 ////////////////////////////////////////////////////////////////////////////////
15295 /// @brief \b Function \b Name: HAL_AUDIO_ConvertInputType2SourceInfo()
15296 /// @brief \b Function \b Description: Convert input type to input source info
15297 /// @param <IN> \b eInputType: Audio input type
15298 /// @param <OUT> \b : Audio input source info
15299 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ConvertInputType2SourceInfo(AUDIO_INPUT_TYPE eInputType)15300 AUDIO_SOURCE_INFO_TYPE HAL_AUDIO_ConvertInputType2SourceInfo(AUDIO_INPUT_TYPE eInputType)
15301 {
15302 AUDIO_SOURCE_INFO_TYPE eSourceInfo = E_AUDIO_INFO_ADC_IN;
15303
15304 switch(eInputType)
15305 {
15306 case AUDIO_DSP1_DVB_INPUT:
15307 case AUDIO_DSP1_DVB1_INPUT:
15308 case AUDIO_DSP2_DVB_INPUT:
15309 case AUDIO_DSP2_DVB1_INPUT:
15310 case AUDIO_DSP3_DVB_INPUT:
15311 case AUDIO_DSP3_DVB1_INPUT:
15312 case AUDIO_DSP4_DVB_INPUT:
15313 eSourceInfo = E_AUDIO_INFO_DTV_IN;
15314 break;
15315
15316 case AUDIO_HDMI_INPUT:
15317 case AUDIO_DSP1_HDMI_INPUT:
15318 case AUDIO_DSP1_HDMIx1_INPUT:
15319 case AUDIO_DSP2_HDMI_INPUT:
15320 case AUDIO_DSP2_HDMIx1_INPUT:
15321 case AUDIO_DSP3_HDMI_INPUT:
15322 case AUDIO_DSP3_HDMIx1_INPUT:
15323 eSourceInfo = E_AUDIO_INFO_HDMI_IN;
15324 break;
15325
15326 case AUDIO_DSP1_SIF_INPUT:
15327 case AUDIO_DSP2_SIF_INPUT:
15328 case AUDIO_DSP3_SIF_INPUT:
15329 case AUDIO_DSP4_SIF_INPUT:
15330 eSourceInfo = E_AUDIO_INFO_ATV_IN;
15331 break;
15332
15333 case AUDIO_AUIN0_INPUT:
15334 case AUDIO_AUIN1_INPUT:
15335 case AUDIO_AUIN2_INPUT:
15336 case AUDIO_AUIN3_INPUT:
15337 case AUDIO_AUIN4_INPUT:
15338 case AUDIO_AUIN5_INPUT:
15339 case AUDIO_AUMIC_INPUT:
15340 case AUDIO_ADC2_AUIN0_INPUT:
15341 case AUDIO_ADC2_AUIN1_INPUT:
15342 case AUDIO_ADC2_AUIN2_INPUT:
15343 case AUDIO_ADC2_AUIN3_INPUT:
15344 case AUDIO_ADC2_AUIN4_INPUT:
15345 case AUDIO_ADC2_AUIN5_INPUT:
15346 case AUDIO_ADC2_AUMIC_INPUT:
15347 eSourceInfo = E_AUDIO_INFO_ADC_IN;
15348 break;
15349
15350 default: break;
15351 }
15352
15353 return eSourceInfo;
15354 }
15355
HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)15356 MS_S32 HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)
15357 {
15358 MS_U8 u8PcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
15359
15360 HALAUDIO_CHECK_SHM_INIT;
15361
15362 switch (enGroup)
15363 {
15364 case E_AUDIO_GROUP_MAIN:
15365 {
15366 switch (g_AudioVars2->eAudioSource)
15367 {
15368 case E_AUDIO_INFO_DTV_IN:
15369 case E_AUDIO_INFO_MM_IN:
15370 case E_AUDIO_INFO_GAME_IN:
15371 {
15372 u8PcmRenderControl = 0; //decoder mode
15373 break;
15374 }
15375
15376 case E_AUDIO_INFO_ATV_IN:
15377 case E_AUDIO_INFO_HDMI_IN:
15378 case E_AUDIO_INFO_ADC_IN:
15379 case E_AUDIO_INFO_SPDIF_IN:
15380 case E_AUDIO_INFO_KTV_IN:
15381 case E_AUDIO_INFO_KTV_STB_IN:
15382 default:
15383 {
15384 u8PcmRenderControl = 2; //stereo mode
15385 break;
15386 }
15387 }
15388
15389 /* configure a default setting to R2's PCM Render accroding to current input source */
15390 printf("%s() enGroup:%x eAudioSource:%x u8PcmRenderControl << 1=%d\n", __FUNCTION__, enGroup,g_AudioVars2->eAudioSource,u8PcmRenderControl << 1);
15391 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8PcmRenderControl << 1));
15392
15393 break;
15394 }
15395
15396 default:
15397 {
15398 break;
15399 }
15400 }
15401
15402 return 0;
15403 }
15404
15405
HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)15406 AUDIO_DSP_CODE_TYPE HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)
15407 {
15408 AUDIO_DSP_CODE_TYPE dspCodeType = AU_DVB_STANDARD_INVALID;
15409
15410 switch (enDecSystem)
15411 {
15412 case MSAPI_AUD_ATV_BTSC:
15413 dspCodeType = AU_SIF_BTSC;
15414 break;
15415 case MSAPI_AUD_ATV_PAL:
15416 dspCodeType = AU_SIF_PALSUM;
15417 break;
15418 case MSAPI_AUD_DVB_MPEG:
15419 dspCodeType = AU_DVB_STANDARD_MPEG;
15420 break;
15421 case MSAPI_AUD_DVB_AC3:
15422 dspCodeType = AU_DVB_STANDARD_AC3;
15423 break;
15424 case MSAPI_AUD_DVB_AC3P:
15425 dspCodeType = AU_DVB_STANDARD_AC3P;
15426 break;
15427 case MSAPI_AUD_DVB_AAC:
15428 dspCodeType = AU_DVB_STANDARD_AAC;
15429 break;
15430 case MSAPI_AUD_DVB_MP3:
15431 dspCodeType = AU_DVB_STANDARD_MP3;
15432 break;
15433 case MSAPI_AUD_DVB_WMA:
15434 dspCodeType = AU_DVB_STANDARD_WMA;
15435 break;
15436 case MSAPI_AUD_DVB_RA8LBR:
15437 dspCodeType = AU_DVB_STANDARD_RA8LBR;
15438 break;
15439 case MSAPI_AUD_DVB_XPCM:
15440 dspCodeType = AU_DVB_STANDARD_XPCM;
15441 break;
15442 case MSAPI_AUD_DVB_DTS:
15443 dspCodeType = AU_DVB_STANDARD_DTS;
15444 break;
15445 case MSAPI_AUD_DVB_MS10_DDT:
15446 dspCodeType = AU_DVB_STANDARD_MS10_DDT;
15447 break;
15448 case MSAPI_AUD_DVB_MS10_DDC:
15449 dspCodeType = AU_DVB_STANDARD_MS10_DDC;
15450 break;
15451 case MSAPI_AUD_DVB_WMA_PRO:
15452 dspCodeType = AU_DVB_STANDARD_WMA_PRO;
15453 break;
15454 case MSAPI_AUD_DVB_FLAC:
15455 dspCodeType = AU_DVB_STANDARD_FLAC;
15456 break;
15457 case MSAPI_AUD_DVB_VORBIS:
15458 dspCodeType = AU_DVB_STANDARD_VORBIS;
15459 break;
15460 case MSAPI_AUD_DVB_DTSLBR:
15461 dspCodeType = AU_DVB_STANDARD_DTSLBR;
15462 break;
15463 case MSAPI_AUD_DVB_DRA:
15464 dspCodeType = AU_DVB_STANDARD_DRA;
15465 break;
15466 default:
15467 break;
15468 }
15469
15470 return dspCodeType;
15471 }
15472
HAL_AUDIO_ResetDspCodeType(void)15473 void HAL_AUDIO_ResetDspCodeType(void)
15474 {
15475 g_AudioVars2->g_DspCodeType = AU_DVB_STANDARD_INVALID;
15476 g_AudioVars2->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
15477 g_AudioVars2->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
15478 }
15479
HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)15480 MS_S32 HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)
15481 {
15482 return 0;
15483 }