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 "../sys/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 #if ASND_R2_SUPPORT
132 #include "sndR2_version.h"
133 #endif
134 #include "../audsp/halAUDSP.h"
135
136 #if defined(MSOS_TYPE_NUTTX)
137 extern int lib_lowprintf(const char *format, ...);
138 #define DBG_PREFIX lib_lowprintf
139 #else
140 #define DBG_PREFIX printf
141 #endif
142
143 #if (defined ANDROID)
144 #include <sys/mman.h>
145 #include <cutils/ashmem.h>
146 #include <cutils/log.h>
147
148 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
149 #define LOGI ALOGI
150 #endif
151
152 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
153 #define LOGE ALOGE
154 #endif
155
156 #define HALAUDIO_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
157 #define HALAUDIO_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
158 #else
159 #ifdef CONFIG_MBOOT
160 #define HALAUDIO_PRINT(fmt, args...)
161 #define HALAUDIO_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
162 #else
163 #define HALAUDIO_PRINT(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
164 #define HALAUDIO_ERROR(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
165 #endif
166 #endif
167
168
169 //-------------------------------------------------------------------------------------------------
170 // Driver Compiler Options
171 //-------------------------------------------------------------------------------------------------
172 #define DBG_AUDIO(args...) //DBG_PREFIX(args)
173 #define DBG_AUDIO_LOAD(args...) //DBG_PREFIX(args)
174 #define DBG_AUDIO_ERROR(args...) //DBG_PREFIX(args)
175 #ifdef CONFIG_MBOOT
176 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
177 #define AUD_DBGMSG(args...)
178 #else
179 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
180 #define AUD_DBGMSG(args...) DBG_PREFIX(args)
181 #endif
182 #define HALAUDIO_CHECK_SHM_INIT \
183 do { \
184 if (g_AudioVars2 == NULL) \
185 { \
186 HALAUDIO_ERROR("%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
187 HALAUDIO_ERROR("%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
188 if (HAL_AUDIO_InitialVars() == FALSE) \
189 { \
190 MS_ASSERT(0); \
191 } \
192 } \
193 } while(0)
194
195 #ifndef MSOS_TYPE_NOS
196 void* MDrv_MPool_PA2KSEG1(void* pAddrPhys);
197 #endif
198
199 //-------------------------------------------------------------------------------------------------
200 // Local Defines
201 //-------------------------------------------------------------------------------------------------
202 #define AUDIO_HAL_ERR(x, args...) //{printf(x, ##args);}
203 #define HINIBBLE(u8Data) ((u8Data) >> 4)
204 //#define LONIBBLE(u8Data) ((u8Data) << 4)
205 #define LONIBBLE(value) ((value) & 0x0f)
206 #if (AUDIO_R2_DMA_READER1_SUPPORT || AUDIO_R2_DMA_READER2_SUPPORT)
207 #define AUDIO_R2_DMA_RDER_CFG_REG(base, offset) ((MS_U32)(base + (offset * 2)))
208 #endif
209
210 #define HW_DMA_RDR1_BUF_UNIT 4096
211
212 #if AUDIO_HW_DMA_READER1_SUPPORT
213 #define HW_DMA_RDR1_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
214 #define HW_DMA_RDR1_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
215 #endif
216
217 #if AUDIO_HW_DMA_READER2_SUPPORT
218 #define HW_DMA_RDR2_BUF_ADDR (DSP2_HW_DMA_READER2_DRAM_BASE * BYTES_IN_MIU_LINE)
219 #define HW_DMA_RDR2_BUF_SIZE ((DSP2_HW_DMA_READER2_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
220 #endif
221
222 #if AUDIO_SW_DMA_READER1_SUPPORT
223 #define SW_DMA_RDR1_BUF_ADDR (DSP2_SW_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
224 #define SW_DMA_RDR1_BUF_SIZE ((DSP2_SW_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
225 #endif
226
227 #if AUDIO_R2_DMA_READER1_SUPPORT
228 #define R2_DMA_RDR1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA1_READER_DRAM_BASE)
229 #define R2_DMA_RDR1_BUF_SIZE MCU_R2_DMA1_READER_DRAM_SIZE
230 #endif
231
232 #if AUDIO_R2_DMA_READER2_SUPPORT
233 #define R2_DMA_RDR2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA2_READER_DRAM_BASE)
234 #define R2_DMA_RDR2_BUF_SIZE MCU_R2_DMA2_READER_DRAM_SIZE
235 #endif
236
237 #if AUDIO_PCM_CAPTURE1_SUPPORT
238 #define PCM_CAPTURE1_BUF_UNIT 128
239 #define PCM_CAPTURE1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
240 #define PCM_CAPTURE1_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
241 #endif
242
243 #if AUDIO_PCM_CAPTURE2_SUPPORT
244 #define PCM_CAPTURE2_BUF_UNIT 128
245 #define PCM_CAPTURE2_BUF_ADDR (DSP2_PCM_CAPTURE2_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
246 #define PCM_CAPTURE2_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
247 #endif
248
249 #if AUDIO_HW_DMA_WRITER1_SUPPORT
250 #define HW_DMA_WTR1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
251 #define HW_DMA_WTR1_BUF_SIZE ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE) * BYTES_IN_MIU_LINE)
252 #endif
253
254 #if AUDIO_MP3_ENCODER1_SUPPORT
255 #define MP3_ENCODER1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MP3_ENC_DRAM_BASE)
256 #define MP3_ENCODER1_BUF_SIZE (MP3_ENC_DRAM_SIZE)
257 #endif
258
259 #if AUDIO_MP3_ENCODER2_SUPPORT
260 #define MP3_ENCODER2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MP3_ENC2_DRAM_BASE)
261 #define MP3_ENCODER2_BUF_SIZE (MP3_ENC2_DRAM_SIZE)
262 #endif
263
264 #ifndef UNUSED
265 #define UNUSED(x) ((x)=(x))
266 #endif
267
268 #define StereoAACOutputPCM 0
269
270 //-------------------------------------------------------------------------------------------------
271 // Local Structures
272 //-------------------------------------------------------------------------------------------------
273 static MS_U8 SIF_MailBoxArray[12];
274
275 //-------------------------------------------------------------------------------------------------
276 // Global Variables
277 //-------------------------------------------------------------------------------------------------
278 AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
279 MS_U16 g_BalanceMask = 0x0000;
280 MS_BOOL g_bAudio_loadcode_from_dram = 0, g_bIsDTV;
281 MS_VIRT _gMIO_MapBase;
282 MS_S32 _s32AUDIOMutex = -1;
283 MS_S32 _s32AUDIOMutexReboot = -1;
284 MS_S32 _s32MutexLoadCode = -1;
285 MS_S32 _s32AUDIOMutexIDMA = -1;
286 extern MS_BOOL g_bDSPLoadCode;
287 MS_U32 g_u32bDTSCD = 0x00;
288 MS_U8 CheckPlayDoneCnt = 0;
289 extern AUDIO_SHARED_VARS2 * g_AudioVars2;
290
291 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
292 #else
293 AUDIO_SHARED_VARS2 g_audioShared;
294 #endif
295
296 #ifndef MSOS_TYPE_NUTTX
297 static MS_BOOL g_bAudioTeeInfoShmInitFlag = FALSE;
298 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
299 #else
300 AUDIO_TEE_INFO_SHARE_MEM gAudioTeeInfoShm;
301 #endif
302 AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm = NULL;
303
304 MS_BOOL g_bAudioTeeEnabled = FALSE, g_bAudioTeeMbxInitialized = FALSE;
305 MS_BOOL g_bDecDspSecureTeeAccessed = FALSE, g_bSndDspSecureTeeAccessed = FALSE;
306 #endif
307
308 //-------------------------------------------------------------------------------------------------
309 // Local Variables
310 //-------------------------------------------------------------------------------------------------
311 static MS_U32 curr_OS_Time=0;
312 static MS_S64 curr_PTS = 0;
313 static MS_BOOL g_bInitShmFlag = FALSE;
314 static MS_BOOL g_bEncodeDoneFlag = 0;
315 // for HW DMA Reader
316 static MS_U8 * dmaReader_writePtr;
317 static MS_U8 * dmaReader_bufStartAddress;
318 static MS_U8 * dmaReader_bufEndAddress;
319
320
321 static AUDIO_DEC_ID DTVDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
322 static AUDIO_DEC_ID HDMIDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
323 static AUDIO_DEC_ID MMDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
324 static AUDIO_DEC_ID VDDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_INVALID , AU_DEC_INVALID};
325
326 #ifdef MSOS_TYPE_NUTTX
327 static MS_S32 _s32MadEventId = -1;
328 static MS_S32 _s32MadTaskId = -1;
329 static MBX_Msg TeeToReeMbxAckMsg;
330 static MBX_Msg msg;
331 static void _MAD_Proc(void);
332 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue);
333 #endif
334
335 MS_PHY g_pcm_capture_base_addr = 0;
336 MS_PHY g_pcm_capture2_base_addr = 0;
337
338 MS_U8 g_DSPMadMIUBank[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
339 MS_PHY g_DSPBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
340 MS_PHY g_DSPMadBaseBufferAdr[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
341 MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
342 extern MS_PHY (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
343 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
344 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
345 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
346
347 extern MS_U32 g_AudioDumpInfoCtrl;
348 extern MS_BOOL bIsNonPCMInDec2;
349 extern MS_U32 EncFrameIdx;
350 extern MS_U32 EncBuf_W_idx;
351 extern MS_U8 EncBuf_Count;
352 extern AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
353
354 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
355 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
356 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
357
358 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
359
360
361 const MS_U32 u32PathArray[8]={0x2C64, 0x2C66, 0x2C68, 0x2C6A, 0x2C65, 0x2C67, 0x2C69, 0x2C6B};
362
363 //Refine power on sequence for earphone & DAC pop noise issue
364 const AUDIO_REG_TYPE AudioPreInitTbl_Clock_0[] =
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}, //[6:5] Set AUPLL_KP0_OUT = 3840fs clock for I2S
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 {0x160346, 0xff, 0x12}, //[7:0] loop_div_second, R2 clock = 0x12 * 24 = 432MHz
386 {0xffffff, 0x01, 0x01}, // delay 1m sec
387
388 //----------------AUR2_1PLL------------------------//Item 22
389 {0x160362, 0xff, 0x01}, //
390 {0x160363, 0xff, 0x00}, //[8] Set AUR2PLL power down = 0
391 {0x160366, 0xff, 0x19}, //[7:0] loop_div_second, R2 clock = 0x19 * 24 = 600MHz
392 {0xffffff, 0x01, 0x01}, // delay 1m sec
393
394 //---------------- DFS ---------------------------//Item 36
395 {0x163c61, 0x03, 0x00}, //[9:8] CLK DSP DFS SEL[1:0] = 0
396 {0x163c61, 0x10, 0x00}, //[12] CLK DSP DFS SEL[2] = 0
397 {0x163c61, 0x08, 0x08}, //[11] CLK DSP DFS EN
398 {0x163c60, 0x1f, 0x1f}, //[4:0] DSP DFS DIV
399 {0x163c60, 0x40, 0x40}, //[6] DSP DFS EN
400 {0x163c60, 0x80, 0x80}, //[7] DSP DFS UPDATE
401 {0x163c63, 0x03, 0x00}, //[9:8] CLK R2 DFS SEL[1:0] = 0
402 {0x163c63, 0x10, 0x00}, //[12] CLK R2 DFS SEL[2] = 0
403 {0x163c63, 0x08, 0x08}, //[11] CLK R2 DFS EN
404 {0x163c62, 0x1f, 0x1f}, //[4:0] R2 DFS DIV
405 {0x163c62, 0x40, 0x40}, //[6] R2 DFS EN
406 {0x163c62, 0x80, 0x80}, //[7] R2 DFS UPDATE
407
408 //---------------- Enable CLK----------------------------//Item 32
409 {0x112ca4, 0xff, 0xff}, //[10:0] CLKGEN's clock enable
410 {0x112ca5, 0xff, 0x1f},
411 {0x112cb2, 0x90, 0x90}, //[7] CLK R2 EN[3], [4] CLK PARSER EN
412 {0x112cb3, 0x60, 0x60}, //[14:13] CLK R2 EN[2:1]
413 {0x112ccb, 0x3c, 0x3c}, //[13:10] CLK DSP EN[4:1]
414 {0x163e04, 0x04, 0x04}, //[1:0] REG_PasDMA_RIU_W_SEL
415 {0x163e04, 0x03, 0x01}, //[2] REG_ENABLE_CLK_PasDMA_RIU_BRG
416 {0x163c65, 0x08, 0x08}, //[11] CLK R2 WB EN
417
418 {0xffffff, 0x00, 0x00}, // end of table
419 };
420
421 const AUDIO_REG_TYPE AudioPreInitTbl_Clock_1[] =
422 {
423 //----------------Audio Reset---------------------------//Item 24
424 {0x112c00, 0xff, 0x0d},
425 {0x112c01, 0xff, 0x7f},
426 {0x112c00, 0xff, 0x0f}, //[1] CLKGEN_RESET
427 {0x112c01, 0xff, 0x7f},
428 {0x112c00, 0xff, 0x0d},
429 {0x112c01, 0xff, 0x7f},
430 {0x112c00, 0xff, 0x00},
431 {0x112c01, 0xff, 0x00},
432
433 //-----------------Synthesizer--------------------------//Item 29
434 {0x112bcf, 0x01, 0x01}, // DVB1
435 {0x112bce, 0x01, 0x01},
436 {0x112ba8, 0xff, 0x94},
437 {0x112ba9, 0xff, 0x11},
438 {0x112baa, 0xff, 0x00},
439 {0x112bab, 0xff, 0x00},
440 {0x112c60, 0x80, 0x80},
441 {0x112bce, 0x01, 0x00},
442 {0x112bcf, 0x02, 0x02}, // DVB2
443 {0x112bce, 0x02, 0x02},
444 {0x112bac, 0xff, 0x94},
445 {0x112bad, 0xff, 0x11},
446 {0x112bae, 0xff, 0x00},
447 {0x112baf, 0xff, 0x00},
448 {0x112c62, 0x80, 0x80},
449 {0x112bce, 0x02, 0x00},
450 {0x112bcf, 0x04, 0x04}, // DVB3
451 {0x112bce, 0x04, 0x04},
452 {0x112bb0, 0xff, 0x94},
453 {0x112bb1, 0xff, 0x11},
454 {0x112bb2, 0xff, 0x00},
455 {0x112bb3, 0xff, 0x00},
456 {0x112c61, 0x80, 0x80},
457 {0x112bce, 0x04, 0x00},
458 {0x112bcf, 0x08, 0x08}, // DVB4
459 {0x112bce, 0x08, 0x08},
460 {0x112bb4, 0xff, 0x94},
461 {0x112bb5, 0xff, 0x11},
462 {0x112bb6, 0xff, 0x00},
463 {0x112bb7, 0xff, 0x00},
464 {0x112c63, 0x80, 0x80},
465 {0x112bce, 0x08, 0x00},
466 {0x112bcf, 0x10, 0x10}, // NonPCM
467 {0x112bce, 0x20, 0x20},
468 {0x112bb8, 0xff, 0x94},
469 {0x112bb9, 0xff, 0x11},
470 {0x112bba, 0xff, 0x00},
471 {0x112bbb, 0xff, 0x00},
472 {0x112c8b, 0x40, 0x40},
473 {0x112bce, 0x20, 0x00},
474 {0x112bcf, 0x20, 0x20}, // NonPCM2
475 {0x112bce, 0x10, 0x10},
476 {0x112bd0, 0xff, 0x94},
477 {0x112bd1, 0xff, 0x11},
478 {0x112bd2, 0xff, 0x00},
479 {0x112bd3, 0xff, 0x00},
480 {0x112c5f, 0x40, 0x40},
481 {0x112bce, 0x10, 0x00},
482 {0x112bcf, 0x40, 0x40}, // NonPCM3
483 {0x112bcf, 0x80, 0x80},
484 {0x112bd6, 0xff, 0x94},
485 {0x112bd7, 0xff, 0x11},
486 {0x112bd8, 0xff, 0x00},
487 {0x112bd9, 0xff, 0x00},
488 {0x112c48, 0x80, 0x80},
489 {0x112bcf, 0x80, 0x00},
490 {0x112c25, 0x20, 0x20}, // DVB5
491 {0x112c25, 0x10, 0x10},
492 {0x112c26, 0xff, 0x94},
493 {0x112c27, 0xff, 0x11},
494 {0x112c28, 0xff, 0x00},
495 {0x112c29, 0xff, 0x00},
496 {0x112c25, 0x80, 0x80},
497 {0x112c25, 0x10, 0x00},
498 {0x112c24, 0x80, 0x80}, // select from Decode5 from SE
499 {0x112c25, 0x02, 0x02}, // DVB6
500 {0x112c25, 0x01, 0x01},
501 {0x112c2a, 0xff, 0x94},
502 {0x112c2b, 0xff, 0x11},
503 {0x112c2c, 0xff, 0x00},
504 {0x112c2d, 0xff, 0x00},
505 {0x112c25, 0x08, 0x08},
506 {0x112c25, 0x01, 0x00},
507 {0x112c24, 0x40, 0x40}, // select from Decode6 from SE
508 {0x112bcf, 0x01, 0x00}, // DVB1 is controlled by DSP/R2
509 {0x112bcf, 0x02, 0x00}, // DVB2 is controlled by DSP/R2
510 {0x112bcf, 0x04, 0x00}, // DVB3 is controlled by DSP/R2
511 {0x112bcf, 0x08, 0x00}, // DVB4 is controlled by DSP/R2
512 {0x112c25, 0x20, 0x00}, // DVB5 is controlled by DSP/R2
513 {0x112c25, 0x02, 0x00}, // DVB6 is controlled by DSP/R2
514 {0x112bcf, 0x10, 0x00}, // NonPCM1 is controlled by DSP/R2
515 {0x112bcf, 0x20, 0x00}, // NonPCM2 is controlled by DSP/R2
516 {0x112bcf, 0x40, 0x00}, // NonPCM3 is controlled by DSP/R2
517
518 //-----------------AudioBand----------------------------//Item 21
519 {0x112b58, 0xff, 0x00}, //[15:0] SDM fix value
520 {0x112b59, 0xff, 0x00},
521 {0x112b55, 0x08, 0x00}, //[11] SDM fix enable
522 {0x112b46, 0xff, 0x00}, //[15:0] Enable Group C
523 {0x112b47, 0xff, 0xff},
524 {0x112b56, 0xff, 0x30}, //[15:0] Enable ADC1/2
525 {0x112b57, 0xff, 0x00},
526 {0x112c6e, 0xff, 0x88}, //[7:0] Enable Grp A/B
527 {0x112b32, 0xff, 0x10}, //[4] SDM fix MSB enable
528 {0x112b50, 0xff, 0x80}, //[15:0] DC offset 9L value
529 {0x112b51, 0xff, 0x00},
530 {0x112b10, 0xff, 0x80}, //[15:0] DC offset 17L value
531 {0x112b11, 0xff, 0x00},
532 {0x112b60, 0xff, 0xc0},
533 {0x112b61, 0xff, 0x38},
534 {0x112b62, 0xff, 0x38},
535 {0x112b63, 0xff, 0x38},
536 {0x112b40, 0xff, 0x4e}, //[15:0] Init CODEC SRC
537 {0x112b41, 0xff, 0x00},
538 {0x112b54, 0xc0, 0x80}, //[7:6] DITHER select 17L 0.5LSB
539 {0x112b55, 0x07, 0x01}, //[10:8] DITHER select 9L 0.5LSB
540 {0x112b52, 0xff, 0x0f}, //[3:0] SDM DC offset enable
541 {0x112b53, 0xff, 0xf0}, //[15:12] SDM Dither enable
542 {0x112b40, 0xff, 0x0c}, //[15:0] Init CODEC SRC
543 {0x112b41, 0xff, 0x00},
544 {0x112b54, 0x01, 0x01}, //[0] SDM EN
545
546 //-----------------De-POP_1-----------------------------//Item 25
547 // auto depop
548 {0x112cdc, 0xff, 0x30}, // wriu -w 0x112cdc 0x2230
549 {0x112cdd, 0xff, 0x22},
550 {0x112cde, 0xff, 0x00}, // wriu -w 0x112cde 0x0000
551 {0x112cdf, 0xff, 0x00},
552 {0x112ce6, 0xff, 0x01}, // wriu -w 0x112ce6 0x0001
553 {0x112ce7, 0xff, 0x00},
554 {0x112ce8, 0xff, 0x00}, // wriu -w 0x112ce8 0x8000
555 {0x112ce9, 0xff, 0x80},
556 {0x112cec, 0xff, 0x90}, // wriu -w 0x112cec 0x0090
557 {0x112ced, 0xff, 0x00},
558 {0x112cee, 0xff, 0x00}, // wriu -w 0x112cee 0x0000
559 {0x112cef, 0xff, 0x00},
560 {0x112cf6, 0xff, 0x00}, // wriu -w 0x112cf6 0x0000
561 {0x112cf7, 0xff, 0x00},
562 {0x112cf8, 0xff, 0x00}, // wriu -w 0x112cf8 0x0000
563 {0x112cf9, 0xff, 0x00},
564 {0x112e70, 0xff, 0x00}, // wriu -w 0x112e70 0x2A00
565 {0x112e71, 0xff, 0x2A},
566 {0x112e72, 0xff, 0xF0}, // wriu -w 0x112e72 0xF0
567 {0x112e73, 0xff, 0x00},
568 {0x112ec0, 0xff, 0x0C}, // wriu -w 0x112ec0 0xC
569 {0x112ec1, 0xff, 0x00},
570 {0x112ec2, 0xff, 0x08}, // wriu -w 0x112ec2 0x8
571 {0x112ec3, 0xff, 0x00},
572 {0x112ec4, 0xff, 0x08}, // wriu -w 0x112ec4 0x8
573 {0x112ec5, 0xff, 0x00},
574 {0x112ec6, 0xff, 0x08}, // wriu -w 0x112ec6 0x8
575 {0x112ec7, 0xff, 0x00},
576 {0x112ec8, 0xff, 0x38}, // wriu -w 0x112ec8 0x38
577 {0x112ec9, 0xff, 0x00},
578 {0x112eca, 0xff, 0x08}, // wriu -w 0x112eca 0x8
579 {0x112ecb, 0xff, 0x00},
580 {0x112ecc, 0xff, 0x3A}, // wriu -w 0x112ecc 0x3A
581 {0x112ecd, 0xff, 0x00},
582 {0x112ece, 0xff, 0x08}, // wriu -w 0x112ece 0x8
583 {0x112ecf, 0xff, 0x00},
584 {0x112ed0, 0xff, 0x38}, // wriu -w 0x112ed0 0x138
585 {0x112ed1, 0xff, 0x01},
586 {0x112ed2, 0xff, 0x08}, // wriu -w 0x112ed2 0x8
587 {0x112ed3, 0xff, 0x00},
588 {0x112ed4, 0xff, 0x38}, // wriu -w 0x112ed4 0x138
589 {0x112ed5, 0xff, 0x01},
590 {0x112ed6, 0xff, 0x08}, // wriu -w 0x112ed6 0x8
591 {0x112ed7, 0xff, 0x00},
592 {0x112e68, 0xff, 0x00}, // wriu -w 0x112e68 0x6D00
593 {0x112e69, 0xff, 0x6D},
594 {0x112e6a, 0xff, 0x01}, // wriu -w 0x112e6a 0x0101
595 {0x112e6b, 0xff, 0x01},
596 {0x112e6c, 0xff, 0x23}, // wriu -w 0x112e6c 0x1223
597 {0x112e6d, 0xff, 0x12},
598 {0x112e6e, 0xff, 0x00}, // wriu -w 0x112e6e 0x0000
599 {0x112e6f, 0xff, 0x00},
600 {0x112ed8, 0xff, 0x09}, // wriu -w 0x112ed8 0x0009
601 {0x112ed9, 0xff, 0x00},
602 {0x112cdc, 0xff, 0x00}, // wriu -w 0x112cdc 0x0
603 {0x112cdd, 0xff, 0x00},
604 {0x112cde, 0xff, 0x00}, // wriu -w 0x112cde 0x800
605 {0x112cdf, 0xff, 0x08},
606 {0x112ce6, 0xff, 0x00}, // wriu -w 0x112ce6 0x0
607 {0x112ce7, 0xff, 0x00},
608 {0x112ce8, 0xff, 0x00}, // wriu -w 0x112ce8 0x0
609 {0x112ce9, 0xff, 0x00},
610 {0x112cec, 0xff, 0x00}, // wriu -w 0x112cec 0x0
611 {0x112ced, 0xff, 0x00},
612 {0x112cee, 0xff, 0x00}, // wriu -w 0x112cee 0x0
613 {0x112cef, 0xff, 0x00},
614 {0x112cf6, 0xff, 0x84}, // wriu -w 0x112cf6 0x2184
615 {0x112cf7, 0xff, 0x21},
616 {0x112cf8, 0xff, 0x00}, // wriu -w 0x112cf8 0x0
617 {0x112cf9, 0xff, 0x00},
618
619 {0xffffff, 0x00, 0x00}, // end of table
620 };
621
622 const AUDIO_REG_TYPE AudioInitTbl_0[]=
623 {
624 //-----------------De-POP_2-----------------------------//Item 26
625
626 //-----------------Input: HDMI (only Vivaldi side)------//Item 1
627 {0x112c44, 0xff, 0x00}, // [4:0] HDMI Matrix CFG
628 {0x112c45, 0xff, 0x00}, // [12:8]HDMI Matrix WD
629 {0x112c44, 0xff, 0x01}, // [4:0] HDMI Matrix CFG
630 {0x112c45, 0xff, 0x01}, // [12:8]HDMI Matrix WD
631 {0x112c44, 0xff, 0x02}, // [4:0] HDMI Matrix CFG
632 {0x112c45, 0xff, 0x02}, // [12:8]HDMI Matrix WD
633 {0x112c44, 0xff, 0x03}, // [4:0] HDMI Matrix CFG
634 {0x112c45, 0xff, 0x03}, // [12:8]HDMI Matrix WD
635 {0x112c44, 0xff, 0x04}, // [4:0] HDMI Matrix CFG
636 {0x112c45, 0xff, 0x04}, // [12:8]HDMI Matrix WD
637 {0x112c44, 0xff, 0x05}, // [4:0] HDMI Matrix CFG
638 {0x112c45, 0xff, 0x05}, // [12:8]HDMI Matrix WD
639 {0x112c44, 0xff, 0x06}, // [4:0] HDMI Matrix CFG
640 {0x112c45, 0xff, 0x06}, // [12:8]HDMI Matrix WD
641 {0x112c44, 0xff, 0x07}, // [4:0] HDMI Matrix CFG
642 {0x112c45, 0xff, 0x07}, // [12:8]HDMI Matrix WD
643 {0x112c44, 0xff, 0x08}, // [4:0] HDMI Matrix CFG
644 {0x112c45, 0xff, 0x08}, // [12:8]HDMI Matrix WD
645 {0x112c44, 0xff, 0x09}, // [4:0] HDMI Matrix CFG
646 {0x112c45, 0xff, 0x09}, // [12:8]HDMI Matrix WD
647 {0x112c44, 0xff, 0x0a}, // [4:0] HDMI Matrix CFG
648 {0x112c45, 0xff, 0x0a}, // [12:8]HDMI Matrix WD
649 {0x112c44, 0xff, 0x0b}, // [4:0] HDMI Matrix CFG
650 {0x112c45, 0xff, 0x0b}, // [12:8]HDMI Matrix WD
651 {0x112c44, 0xff, 0x0c}, // [4:0] HDMI Matrix CFG
652 {0x112c45, 0xff, 0x0c}, // [12:8]HDMI Matrix WD
653 {0x112c44, 0xff, 0x0d}, // [4:0] HDMI Matrix CFG
654 {0x112c45, 0xff, 0x0d}, // [12:8]HDMI Matrix WD
655 {0x112c44, 0xff, 0x0e}, // [4:0] HDMI Matrix CFG
656 {0x112c45, 0xff, 0x0e}, // [12:8]HDMI Matrix WD
657 {0x112c44, 0xff, 0x0f}, // [4:0] HDMI Matrix CFG
658 {0x112c45, 0xff, 0x0f}, // [12:8]HDMI Matrix WD
659 {0x112c44, 0xff, 0x10}, // [4:0] HDMI Matrix CFG
660 {0x112c45, 0xff, 0x10}, // [12:8]HDMI Matrix WD
661 {0x112c44, 0xff, 0x11}, // [4:0] HDMI Matrix CFG
662 {0x112c45, 0xff, 0x11}, // [12:8]HDMI Matrix WD
663 {0x112c44, 0xff, 0x12}, // [4:0] HDMI Matrix CFG
664 {0x112c45, 0xff, 0x12}, // [12:8]HDMI Matrix WD
665 {0x112c44, 0xff, 0x13}, // [4:0] HDMI Matrix CFG
666 {0x112c45, 0xff, 0x13}, // [12:8]HDMI Matrix WD
667 {0x112c44, 0xff, 0x14}, // [4:0] HDMI Matrix CFG
668 {0x112c45, 0xff, 0x14}, // [12:8]HDMI Matrix WD
669 {0x112c44, 0xff, 0x15}, // [4:0] HDMI Matrix CFG
670 {0x112c45, 0xff, 0x15}, // [12:8]HDMI Matrix WD
671 {0x112c44, 0xff, 0x16}, // [4:0] HDMI Matrix CFG
672 {0x112c45, 0xff, 0x16}, // [12:8]HDMI Matrix WD
673 {0x112c44, 0xff, 0x17}, // [4:0] HDMI Matrix CFG
674 {0x112c45, 0xff, 0x17}, // [12:8]HDMI Matrix WD
675 {0x112c44, 0xff, 0x18}, // [4:0] HDMI Matrix CFG
676 {0x112c45, 0xff, 0x18}, // [12:8]HDMI Matrix WD
677 {0x112c44, 0xff, 0x19}, // [4:0] HDMI Matrix CFG
678 {0x112c45, 0xff, 0x19}, // [12:8]HDMI Matrix WD
679 {0x112c44, 0xff, 0x1a}, // [4:0] HDMI Matrix CFG
680 {0x112c45, 0xff, 0x1a}, // [12:8]HDMI Matrix WD
681 {0x112c44, 0xff, 0x1b}, // [4:0] HDMI Matrix CFG
682 {0x112c45, 0xff, 0x1b}, // [12:8]HDMI Matrix WD
683 {0x112c44, 0xff, 0x1c}, // [4:0] HDMI Matrix CFG
684 {0x112c45, 0xff, 0x1c}, // [12:8]HDMI Matrix WD
685 {0x112c44, 0xff, 0x1d}, // [4:0] HDMI Matrix CFG
686 {0x112c45, 0xff, 0x1d}, // [12:8]HDMI Matrix WD
687 {0x112c44, 0xff, 0x1e}, // [4:0] HDMI Matrix CFG
688 {0x112c45, 0xff, 0x1e}, // [12:8]HDMI Matrix WD
689 {0x112c44, 0xff, 0x1f}, // [4:0] HDMI Matrix CFG
690 {0x112c45, 0xff, 0x1f}, // [12:8]HDMI Matrix WD
691 {0x153d6a, 0xff, 0x7f}, // [6:0] HDMI RX LAUNCH CFG
692 {0x153d18, 0x33, 0x20}, // [2:0]HDMI status channel SEL, [5:4]HDMI status SEL
693 {0x153d19, 0xff, 0xdd}, // [8]HDMI left justified, [9]MSB first, [15:10]HDMI status block start SEL
694 {0x112c47, 0x83, 0x01}, // [8]DSD MODE SW SEL, [9]DSD MODE SW, [15]MCH EN
695 {0x112c48, 0x10, 0x10}, // [4] npcm byte mode
696 {0x112c48, 0x08, 0x08}, // [3] npcm decoder PA/PB order
697 {0x112c48, 0x04, 0x00}, // [2] npcm decoder fast lock
698 {0x112c48, 0x03, 0x00}, // [1:0] npcm decoder time out SEL
699
700 //-----------------Input: I2S (default slave)---------------------------//Item 2
701 {0x112c02, 0xff, 0x0f}, // [3:0] I2S/SIF/SPDIF clk EN, [4]=1 I2S left-justified , [4]=0 I2S format
702 {0x112c03, 0xff, 0xc0}, // [14]AUTO_CLEAR_PC_PD_BAR, [15]SPDIF_IN_BLOCK_NO_CHECK
703 {0x112cae, 0xff, 0x0e}, // [3:1] non-pcm synthesizer source SEL 432MHz
704 {0x112cae, 0x30, 0x00}, // [5:4] spdif rx synthesizer source SEL 432MHz
705 {0x112caf, 0xff, 0x00}, // [15:13]i2s fs synthesizer SEL source clock 216MHz
706
707 //-----------------Input: SPDIF-------------------------//Item 3
708 {0x112c0a, 0xff, 0x70},
709 {0x112c0b, 0xff, 0x13},
710
711 //-----------------Input: ADC---------------------------//Item 4
712
713 //-----------------Decode Path--------------------------//Item 28
714 {0x112c60, 0xff, 0x80}, // Decoder 1 source from DVB1 @@VVV
715 {0x112c61, 0xff, 0x80}, // Decoder 3 source from DVB3 @@VVV
716 {0x112c62, 0xff, 0x80}, // Decoder 2 source from DVB2 @@VVV
717 {0x112c63, 0xff, 0x87}, // Decoder 4 source from SIF @@VVV
718
719 //-----------------SIF init table-----------------------//Item 27/31
720 //call Jeff-CY.Lee(#7019) for VIF_SIF_ini_table.xls
721
722 //-----------------Input: Channel Source----------------//Item 6
723 {0x112c64, 0xff, 0x80}, // CH1: Source0 , CH5: ADC0
724 {0x112c65, 0xff, 0x80}, // Set CH5 default source from decoder
725 {0x112c66, 0xff, 0x80}, // CH2: Source0 , CH6: Source1
726 {0x112c67, 0xff, 0x81},
727 {0x112c68, 0xff, 0x80}, // CH3: Source0 , CH7: Source3
728 {0x112c69, 0xff, 0x83},
729 {0x112c6a, 0xff, 0x80}, // CH4: Source0 , CH8: Source7
730 {0x112c6b, 0xff, 0x87},
731
732 //-----------------Output: I2S (BCK 64fs, msater)--------------------------//Item 10
733 // {0x112c90, 0x40, 0x00},
734 // {0x112c90, 0x1e, 0x00},
735 // {0x112c8d, 0x02, 0x00},
736 // {0x112c8d, 0x01, 0x00},
737 // {0x112c8c, 0x70, 0x20},
738 // {0x112c8c, 0x08, 0x00},
739 // {0x112c8c, 0x07, 0x02},
740 // {0x112c8d, 0x80, 0x80},
741 // {0x112c8d, 0x40, 0x40},
742 // {0x112c8d, 0x08, 0x08},
743 // {0xffffff, 0x01, 0x01}, // delay 1u sec
744 // {0x112c8d, 0x40, 0x00},
745 // {0x112c8d, 0x08, 0x00},
746
747 //-----------------Output: SPDIF TX1--------------------//Item 11
748 {0x112c90, 0x01, 0x00},
749 {0x112c8b, 0x80, 0x80},
750 {0x112c8b, 0x20, 0x00},
751 {0x112c8b, 0x10, 0x00},
752 {0x112c8b, 0x08, 0x00},
753 {0x112c8b, 0x04, 0x00},
754 {0x112c8b, 0x02, 0x00},
755 {0x112c8b, 0x01, 0x00},
756 {0x112c8a, 0x10, 0x10},
757 {0x112c8a, 0x08, 0x00},
758 {0x112c8a, 0x04, 0x00},
759 {0x112c8a, 0x03, 0x00},
760 {0x112c8a, 0x80, 0x80},
761 {0x112c8a, 0x40, 0x40},
762 {0x112c8a, 0x20, 0x20},
763 {0xffffff, 0x01, 0x01}, // delay 1u sec
764 {0x112c8a, 0x40, 0x00},
765 {0x112c8a, 0x20, 0x00},
766 {0x112c8a, 0x90, 0x90},
767
768 //-----------------Output: DAC--------------------------//Item 12
769 {0x112b55, 0x08, 0x00}, // [11] SDM fix disable
770
771 //-----------------Output: SPDIF TX2--------------------//Item 13
772 {0x112c5f, 0x80, 0x80},
773 {0x112c5f, 0x40, 0x40},
774 {0x112c5f, 0x20, 0x00},
775 {0x112c5f, 0x10, 0x00},
776 {0x112c5f, 0x08, 0x00},
777 {0x112c5f, 0x04, 0x00},
778 {0x112c5f, 0x02, 0x00},
779 {0x112c5f, 0x01, 0x00},
780 {0x112c5e, 0x10, 0x10},
781 {0x112c5e, 0x08, 0x00},
782 {0x112c5e, 0x04, 0x00},
783 {0x112c5e, 0x03, 0x00},
784 {0x112c5e, 0x80, 0x80},
785 {0x112c5e, 0x40, 0x40},
786 {0x112c5e, 0x20, 0x20},
787 {0xffffff, 0x01, 0x01}, // delay 1u sec
788 {0x112c5e, 0x40, 0x00},
789 {0x112c5e, 0x20, 0x00},
790 {0x112c5e, 0x90, 0x90},
791
792 //---------------------------------------------------//Item 30
793 {0x112c94, 0x01, 0x01}, // enable CH1 HW force mute, [0] ch1 mute all @@VVV
794 {0x112c95, 0x01, 0x01}, // enable CH5 HW force mute, [8] ch5 mute all @@VVV
795 {0x112c96, 0x01, 0x01}, // enable CH2 HW force mute, [0] ch2 mute all @@VVV
796 {0x112c97, 0x01, 0x01}, // enable CH6 HW force mute, [8] ch6 mute all @@VVV
797 {0x112c98, 0x01, 0x01}, // enable CH3 HW force mute, [0] ch3 mute all @@VVV
798 {0x112c99, 0x01, 0x01}, // enable CH7 HW force mute, [8] ch7 mute all @@VVV
799 {0x112c9a, 0x01, 0x01}, // enable CH4 HW force mute, [0] ch4 mute all @@VVV
800 {0x112c9b, 0x01, 0x01}, // enable CH8 HW force mute, [8] ch8 mute all @@VVV
801
802 //-----------------Interrupt--------------------------//Item 35
803 //IRQE1n = 0x112AA2[7] ? SPDIF_TX : (0x11304E[4] ? SPDIF_TX2 : HDMI_TX)
804 //IRQL1n = 0x112AA2[4] ? SPDIF_TX : (0x11304E[8] ? SPDIF_TX2 : HDMI_TX)
805 //IRQ2n = 0x112AA2[6] ? SPDIF_TX : (0x112AA2[5] ? SPDIF_TX2 : HDMI_TX)
806 {0x112aa2, 0x40, 0x40}, //[6] IRQ2n select SPDIF_TX
807 {0x11304e, 0x10, 0x10}, //[4] IRQE1n select SPDIF_TX2
808 {0x11304f, 0x01, 0x00}, //[8] IRQL1n select HDMI_TX
809
810 //-----------------MIU & DMA Setting---------------------------//Item 34
811 {0x112a44, 0xff, 0x00}, //[15] maddma fifo addr demeta
812 {0x112a45, 0xff, 0x80},
813 {0x112ac4, 0xff, 0x00}, //[15] Sedma fifo addr demeta
814 {0x112ac5, 0xff, 0x80},
815 {0x112a21, 0x04, 0x00}, //[10] maddma fifo new mode
816 {0x112aa1, 0x04, 0x00}, //[10] sedma fifo new mode
817 {0x112a4c, 0x20, 0x20}, //[5] burst mode enable
818 {0x112a4d, 0x20, 0x20}, //[13] burst mode enable
819 {0x112acc, 0x20, 0x20}, //[5] burst mode enable
820 {0x112acd, 0x20, 0x20}, //[13] burst mode enable
821 {0x163d03, 0x60, 0x20}, //[14:13] =01 for auR2 use MIU0, =10 for auR2 use MIU1
822 {0x163d07, 0x60, 0x20}, //[14:13] =01 for auR2_1 use MIU0, =10 for auR2_1 use MIU1
823 {0x112940, 0x20, 0x00}, //[5] enable R2 Write buffer burst mode
824 {0x1129d7, 0x02, 0x02}, //[9] enable R2 dynamic clock gating
825 {0x163040, 0x20, 0x00}, //[5] enable R2_1 Write buffer burst mode
826 {0x1630d7, 0x02, 0x02}, //[9] enable R2_1 dynamic clock gating
827 {0x163e06, 0xff, 0x0f}, // MIU delay1T setting: have bridge & have mcm = 0x0F0F
828 {0x163e07, 0xff, 0x0f}, // MIU delay1T setting: have bridge & no mcm = 0x0000
829 {0x112f68, 0xff, 0xff}, // dma arb
830 {0x112f69, 0xff, 0xff},
831 {0x112f66, 0xff, 0x00}, // dma arb
832 {0x112f67, 0xff, 0x00},
833 {0x112f64, 0xff, 0x00}, // dma arb
834 {0x112f65, 0xff, 0x04},
835 {0x112f62, 0xff, 0x08}, // dma arb
836 {0x112f63, 0xff, 0x20},
837 {0x112f60, 0xff, 0x15}, // dma arb
838 {0x112f61, 0xff, 0x80},
839 {0x112f88, 0xff, 0xff}, // cache arb
840 {0x112f89, 0xff, 0xff},
841 {0x112f86, 0xff, 0x00}, // cache arb
842 {0x112f87, 0xff, 0x00},
843 {0x112f84, 0xff, 0x00}, // cache arb
844 {0x112f85, 0xff, 0x04},
845 {0x112f82, 0xff, 0x08}, // cache arb
846 {0x112f83, 0xff, 0x20},
847 {0x112f80, 0xff, 0x15}, // cache arb
848 {0x112f81, 0xff, 0x80},
849 {0x163d88, 0xff, 0xff}, // R2 arb
850 {0x163d89, 0xff, 0xff},
851 {0x163d86, 0xff, 0x00}, // R2 arb
852 {0x163d87, 0xff, 0x00},
853 {0x163d84, 0xff, 0x00}, // R2 arb
854 {0x163d85, 0xff, 0x04},
855 {0x163d82, 0xff, 0x08}, // R2 arb
856 {0x163d83, 0xff, 0x20},
857 {0x163d80, 0xff, 0x15}, // R2 arb
858 {0x163d81, 0xff, 0x80},
859 {0x163da8, 0xff, 0xff}, // R2_1 arb
860 {0x163da9, 0xff, 0xff},
861 {0x163da6, 0xff, 0x00}, // R2_1 arb
862 {0x163da7, 0xff, 0x00},
863 {0x163da4, 0xff, 0x00}, // R2_1 arb
864 {0x163da5, 0xff, 0x04},
865 {0x163da2, 0xff, 0x08}, // R2_1 arb
866 {0x163da3, 0xff, 0x20},
867 {0x163da0, 0xff, 0x15}, // R2_1 arb
868 {0x163da1, 0xff, 0x80},
869 {0x163e28, 0xff, 0xff}, // dma_l2 arb
870 {0x163e29, 0xff, 0xff},
871 {0x163e26, 0xff, 0x00}, // dma_l2 arb
872 {0x163e27, 0xff, 0x00},
873 {0x163e24, 0xff, 0x00}, // dma_l2 arb
874 {0x163e25, 0xff, 0x04},
875 {0x163e22, 0xff, 0x08}, // dma_l2 arb
876 {0x163e23, 0xff, 0x20},
877 {0x163e20, 0xff, 0x15}, // dma_l2 arb
878 {0x163e21, 0xff, 0x80},
879
880 //---------------- DFS ---------------------------//Item 36
881 {0x163c61, 0x03, 0x00}, //[9:8] CLK DSP DFS SEL[1:0] = 0
882 {0x163c61, 0x10, 0x00}, //[12] CLK DSP DFS SEL[2] = 0
883 {0x163c61, 0x08, 0x08}, //[11] CLK DSP DFS EN
884 {0x163c60, 0x1f, 0x1f}, //[4:0] DSP DFS DIV
885 {0x163c60, 0x40, 0x40}, //[6] DSP DFS EN
886 {0x163c60, 0x80, 0x80}, //[7] DSP DFS UPDATE
887 {0x163c63, 0x03, 0x00}, //[9:8] CLK R2 DFS SEL[1:0] = 0
888 {0x163c63, 0x10, 0x00}, //[12] CLK R2 DFS SEL[2] = 0
889 {0x163c63, 0x08, 0x08}, //[11] CLK R2 DFS EN
890 {0x163c62, 0x1f, 0x1f}, //[4:0] R2 DFS DIV
891 {0x163c62, 0x40, 0x40}, //[6] R2 DFS EN
892 {0x163c62, 0x80, 0x80}, //[7] R2 DFS UPDATE
893
894 //---------------- R2 block clkgen ---------------------------
895
896 //----------------------------------------------------
897 //MCM off and Adress limiter bypass
898 //Note: Only use in audio YMY verification, need to be decided by system top
899 //----------------------------------------------------
900 #if 1
901 //SE DMA
902 {0x163ca1, 0x0f, 0x01}, //[11:8]lower bond address
903 {0x163ca8, 0xff, 0x00}, //[7:0]address low byte
904 {0x163ca9, 0xff, 0x00}, //[15:8]address low byte
905 {0x163caa, 0xff, 0x00}, //[7:0]address high byte
906 {0x163cab, 0xff, 0x00}, //[15:8]address high byte
907 {0x163ca1, 0x0f, 0x02}, //[11:8]upper bond address
908 {0x163ca8, 0xff, 0xff}, //[7:0]address low byte
909 {0x163ca9, 0xff, 0xff}, //[15:8]address low byte
910 {0x163caa, 0xff, 0xff}, //[7:0]address high byte
911 {0x163cab, 0xff, 0xff}, //[15:8]address high byte
912 {0x163ca1, 0x0f, 0x03}, //[11:8]lower bond address
913 {0x163ca8, 0xff, 0x00}, //[7:0]address low byte
914 {0x163ca9, 0xff, 0x00}, //[15:8]address low byte
915 {0x163caa, 0xff, 0x00}, //[7:0]address high byte
916 {0x163cab, 0xff, 0x00}, //[15:8]address high byte
917 {0x163ca1, 0x0f, 0x04}, //[11:8]upper bond address
918 {0x163ca8, 0xff, 0xff}, //[7:0]address low byte
919 {0x163ca9, 0xff, 0xff}, //[15:8]address low byte
920 {0x163caa, 0xff, 0xff}, //[7:0]address high byte
921 {0x163cab, 0xff, 0xff}, //[15:8]address high byte
922 {0x163ca1, 0x0f, 0x05}, //[11:8]lower bond address
923 {0x163ca8, 0xff, 0x00}, //[7:0]address low byte
924 {0x163ca9, 0xff, 0x00}, //[15:8]address low byte
925 {0x163caa, 0xff, 0x00}, //[7:0]address high byte
926 {0x163cab, 0xff, 0x00}, //[15:8]address high byte
927 {0x163ca1, 0x0f, 0x06}, //[11:8]upper bond address
928 {0x163ca8, 0xff, 0xff}, //[7:0]address low byte
929 {0x163ca9, 0xff, 0xff}, //[15:8]address low byte
930 {0x163caa, 0xff, 0xff}, //[7:0]address high byte
931 {0x163cab, 0xff, 0xff}, //[15:8]address high byte
932 {0x163ca1, 0x0f, 0x07}, //[11:8]lower bond address
933 {0x163ca8, 0xff, 0x00}, //[7:0]address low byte
934 {0x163ca9, 0xff, 0x00}, //[15:8]address low byte
935 {0x163caa, 0xff, 0x00}, //[7:0]address high byte
936 {0x163cab, 0xff, 0x00}, //[15:8]address high byte
937 {0x163ca1, 0x0f, 0x08}, //[11:8]upper bond address
938 {0x163ca8, 0xff, 0xff}, //[7:0]address low byte
939 {0x163ca9, 0xff, 0xff}, //[15:8]address low byte
940 {0x163caa, 0xff, 0xff}, //[7:0]address high byte
941 {0x163cab, 0xff, 0xff}, //[15:8]address high byte
942 {0x163ca1, 0x90, 0x90}, //[15]address_0 en
943 //SE cache
944 {0x163cb1, 0x0f, 0x01}, //[11:8]lower bond address
945 {0x163cb8, 0xff, 0x00}, //[7:0]address low byte
946 {0x163cb9, 0xff, 0x00}, //[15:8]address low byte
947 {0x163cba, 0xff, 0x00}, //[7:0]address high byte
948 {0x163cbb, 0xff, 0x00}, //[15:8]address high byte
949 {0x163cb1, 0x0f, 0x02}, //[11:8]upper bond address
950 {0x163cb8, 0xff, 0xff}, //[7:0]address low byte
951 {0x163cb9, 0xff, 0xff}, //[15:8]address low byte
952 {0x163cba, 0xff, 0xff}, //[7:0]address high byte
953 {0x163cbb, 0xff, 0xff}, //[15:8]address high byte
954 {0x163cb1, 0x80, 0x80}, //[15]address_0 en
955 //R2 D
956 {0x163cc1, 0x0f, 0x01}, //[11:8]lower bond address
957 {0x163cc8, 0xff, 0x00}, //[7:0]address low byte
958 {0x163cc9, 0xff, 0x00}, //[15:8]address low byte
959 {0x163cca, 0xff, 0x00}, //[7:0]address high byte
960 {0x163ccb, 0xff, 0x00}, //[15:8]address high byte
961 {0x163cc1, 0x0f, 0x02}, //[11:8]upper bond address
962 {0x163cc8, 0xff, 0xff}, //[7:0]address low byte
963 {0x163cc9, 0xff, 0xff}, //[15:8]address low byte
964 {0x163cca, 0xff, 0xff}, //[7:0]address high byte
965 {0x163ccb, 0xff, 0xff}, //[15:8]address high byte
966 {0x163cc1, 0x0f, 0x03}, //[11:8]lower bond address
967 {0x163cc8, 0xff, 0x00}, //[7:0]address low byte
968 {0x163cc9, 0xff, 0x00}, //[15:8]address low byte
969 {0x163cca, 0xff, 0x00}, //[7:0]address high byte
970 {0x163ccb, 0xff, 0x00}, //[15:8]address high byte
971 {0x163cc1, 0x0f, 0x04}, //[11:8]upper bond address
972 {0x163cc8, 0xff, 0xff}, //[7:0]address low byte
973 {0x163cc9, 0xff, 0xff}, //[15:8]address low byte
974 {0x163cca, 0xff, 0xff}, //[7:0]address high byte
975 {0x163ccb, 0xff, 0xff}, //[15:8]address high byte
976 {0x163cc1, 0x0f, 0x05}, //[11:8]lower bond address
977 {0x163cc8, 0xff, 0x00}, //[7:0]address low byte
978 {0x163cc9, 0xff, 0x00}, //[15:8]address low byte
979 {0x163cca, 0xff, 0x00}, //[7:0]address high byte
980 {0x163ccb, 0xff, 0x00}, //[15:8]address high byte
981 {0x163cc1, 0x0f, 0x06}, //[11:8]upper bond address
982 {0x163cc8, 0xff, 0xff}, //[7:0]address low byte
983 {0x163cc9, 0xff, 0xff}, //[15:8]address low byte
984 {0x163cca, 0xff, 0xff}, //[7:0]address high byte
985 {0x163ccb, 0xff, 0xff}, //[15:8]address high byte
986 {0x163cc1, 0x0f, 0x07}, //[11:8]lower bond address
987 {0x163cc8, 0xff, 0x00}, //[7:0]address low byte
988 {0x163cc9, 0xff, 0x00}, //[15:8]address low byte
989 {0x163cca, 0xff, 0x00}, //[7:0]address high byte
990 {0x163ccb, 0xff, 0x00}, //[15:8]address high byte
991 {0x163cc1, 0x0f, 0x08}, //[11:8]upper bond address
992 {0x163cc8, 0xff, 0xff}, //[7:0]address low byte
993 {0x163cc9, 0xff, 0xff}, //[15:8]address low byte
994 {0x163cca, 0xff, 0xff}, //[7:0]address high byte
995 {0x163ccb, 0xff, 0xff}, //[15:8]address high byte
996 {0x163cc1, 0x90, 0x90}, //[15]address_0 en
997 //R2 I
998 {0x163cd1, 0x0f, 0x01}, //[11:8]lower bond address
999 {0x163cd8, 0xff, 0x00}, //[7:0]address low byte
1000 {0x163cd9, 0xff, 0x00}, //[15:8]address low byte
1001 {0x163cda, 0xff, 0x00}, //[7:0]address high byte
1002 {0x163cdb, 0xff, 0x00}, //[15:8]address high byte
1003 {0x163cd1, 0x0f, 0x02}, //[11:8]upper bond address
1004 {0x163cd8, 0xff, 0xff}, //[7:0]address low byte
1005 {0x163cd9, 0xff, 0xff}, //[15:8]address low byte
1006 {0x163cda, 0xff, 0xff}, //[7:0]address high byte
1007 {0x163cdb, 0xff, 0xff}, //[15:8]address high byte
1008 {0x163cd1, 0x80, 0x80}, //[15]address_0 en
1009 //R2_1 D
1010 {0x163ce1, 0x0f, 0x01}, //[11:8]lower bond address
1011 {0x163ce8, 0xff, 0x00}, //[7:0]address low byte
1012 {0x163ce9, 0xff, 0x00}, //[15:8]address low byte
1013 {0x163cea, 0xff, 0x00}, //[7:0]address high byte
1014 {0x163ceb, 0xff, 0x00}, //[15:8]address high byte
1015 {0x163ce1, 0x0f, 0x02}, //[11:8]upper bond address
1016 {0x163ce8, 0xff, 0xff}, //[7:0]address low byte
1017 {0x163ce9, 0xff, 0xff}, //[15:8]address low byte
1018 {0x163cea, 0xff, 0xff}, //[7:0]address high byte
1019 {0x163ceb, 0xff, 0xff}, //[15:8]address high byte
1020 {0x163ce1, 0x0f, 0x03}, //[11:8]lower bond address
1021 {0x163ce8, 0xff, 0x00}, //[7:0]address low byte
1022 {0x163ce9, 0xff, 0x00}, //[15:8]address low byte
1023 {0x163cea, 0xff, 0x00}, //[7:0]address high byte
1024 {0x163ceb, 0xff, 0x00}, //[15:8]address high byte
1025 {0x163ce1, 0x0f, 0x04}, //[11:8]upper bond address
1026 {0x163ce8, 0xff, 0xff}, //[7:0]address low byte
1027 {0x163ce9, 0xff, 0xff}, //[15:8]address low byte
1028 {0x163cea, 0xff, 0xff}, //[7:0]address high byte
1029 {0x163ceb, 0xff, 0xff}, //[15:8]address high byte
1030 {0x163ce1, 0x0f, 0x05}, //[11:8]lower bond address
1031 {0x163ce8, 0xff, 0x00}, //[7:0]address low byte
1032 {0x163ce9, 0xff, 0x00}, //[15:8]address low byte
1033 {0x163cea, 0xff, 0x00}, //[7:0]address high byte
1034 {0x163ceb, 0xff, 0x00}, //[15:8]address high byte
1035 {0x163ce1, 0x0f, 0x06}, //[11:8]upper bond address
1036 {0x163ce8, 0xff, 0xff}, //[7:0]address low byte
1037 {0x163ce9, 0xff, 0xff}, //[15:8]address low byte
1038 {0x163cea, 0xff, 0xff}, //[7:0]address high byte
1039 {0x163ceb, 0xff, 0xff}, //[15:8]address high byte
1040 {0x163ce1, 0x0f, 0x07}, //[11:8]lower bond address
1041 {0x163ce8, 0xff, 0x00}, //[7:0]address low byte
1042 {0x163ce9, 0xff, 0x00}, //[15:8]address low byte
1043 {0x163cea, 0xff, 0x00}, //[7:0]address high byte
1044 {0x163ceb, 0xff, 0x00}, //[15:8]address high byte
1045 {0x163ce1, 0x0f, 0x08}, //[11:8]upper bond address
1046 {0x163ce8, 0xff, 0xff}, //[7:0]address low byte
1047 {0x163ce9, 0xff, 0xff}, //[15:8]address low byte
1048 {0x163cea, 0xff, 0xff}, //[7:0]address high byte
1049 {0x163ceb, 0xff, 0xff}, //[15:8]address high byte
1050 {0x163ce1, 0x90, 0x90}, //[15]address_0 en
1051 //R2_1 I
1052 {0x163cf1, 0x0f, 0x01}, //[11:8]lower bond address
1053 {0x163cf8, 0xff, 0x00}, //[7:0]address low byte
1054 {0x163cf9, 0xff, 0x00}, //[15:8]address low byte
1055 {0x163cfa, 0xff, 0x00}, //[7:0]address high byte
1056 {0x163cfb, 0xff, 0x00}, //[15:8]address high byte
1057 {0x163cf1, 0x0f, 0x02}, //[11:8]upper bond address
1058 {0x163cf8, 0xff, 0xff}, //[7:0]address low byte
1059 {0x163cf9, 0xff, 0xff}, //[15:8]address low byte
1060 {0x163cfa, 0xff, 0xff}, //[7:0]address high byte
1061 {0x163cfb, 0xff, 0xff}, //[15:8]address high byte
1062 {0x163cf1, 0x80, 0x80}, //[15]address_0 en
1063 //DEC DMA
1064 {0x163d31, 0x0f, 0x01}, //[11:8]lower bond address
1065 {0x163d38, 0xff, 0x00}, //[7:0]address low byte
1066 {0x163d39, 0xff, 0x00}, //[15:8]address low byte
1067 {0x163d3a, 0xff, 0x00}, //[7:0]address high byte
1068 {0x163d3b, 0xff, 0x00}, //[15:8]address high byte
1069 {0x163d31, 0x0f, 0x02}, //[11:8]upper bond address
1070 {0x163d38, 0xff, 0xff}, //[7:0]address low byte
1071 {0x163d39, 0xff, 0xff}, //[15:8]address low byte
1072 {0x163d3a, 0xff, 0xff}, //[7:0]address high byte
1073 {0x163d3b, 0xff, 0xff}, //[15:8]address high byte
1074 {0x163d31, 0x0f, 0x03}, //[11:8]lower bond address
1075 {0x163d38, 0xff, 0x00}, //[7:0]address low byte
1076 {0x163d39, 0xff, 0x00}, //[15:8]address low byte
1077 {0x163d3a, 0xff, 0x00}, //[7:0]address high byte
1078 {0x163d3b, 0xff, 0x00}, //[15:8]address high byte
1079 {0x163d31, 0x0f, 0x04}, //[11:8]upper bond address
1080 {0x163d38, 0xff, 0xff}, //[7:0]address low byte
1081 {0x163d39, 0xff, 0xff}, //[15:8]address low byte
1082 {0x163d3a, 0xff, 0xff}, //[7:0]address high byte
1083 {0x163d3b, 0xff, 0xff}, //[15:8]address high byte
1084 {0x163d31, 0x0f, 0x05}, //[11:8]lower bond address
1085 {0x163d38, 0xff, 0x00}, //[7:0]address low byte
1086 {0x163d39, 0xff, 0x00}, //[15:8]address low byte
1087 {0x163d3a, 0xff, 0x00}, //[7:0]address high byte
1088 {0x163d3b, 0xff, 0x00}, //[15:8]address high byte
1089 {0x163d31, 0x0f, 0x06}, //[11:8]upper bond address
1090 {0x163d38, 0xff, 0xff}, //[7:0]address low byte
1091 {0x163d39, 0xff, 0xff}, //[15:8]address low byte
1092 {0x163d3a, 0xff, 0xff}, //[7:0]address high byte
1093 {0x163d3b, 0xff, 0xff}, //[15:8]address high byte
1094 {0x163d31, 0x0f, 0x07}, //[11:8]lower bond address
1095 {0x163d38, 0xff, 0x00}, //[7:0]address low byte
1096 {0x163d39, 0xff, 0x00}, //[15:8]address low byte
1097 {0x163d3a, 0xff, 0x00}, //[7:0]address high byte
1098 {0x163d3b, 0xff, 0x00}, //[15:8]address high byte
1099 {0x163d31, 0x0f, 0x08}, //[11:8]upper bond address
1100 {0x163d38, 0xff, 0xff}, //[7:0]address low byte
1101 {0x163d39, 0xff, 0xff}, //[15:8]address low byte
1102 {0x163d3a, 0xff, 0xff}, //[7:0]address high byte
1103 {0x163d3b, 0xff, 0xff}, //[15:8]address high byte
1104 {0x163d31, 0x90, 0x90}, //[15]address_0 en
1105 //R2 BDMA
1106 {0x163d41, 0x0f, 0x01}, //[11:8]lower bond address
1107 {0x163d48, 0xff, 0x00}, //[7:0]address low byte
1108 {0x163d49, 0xff, 0x00}, //[15:8]address low byte
1109 {0x163d4a, 0xff, 0x00}, //[7:0]address high byte
1110 {0x163d4b, 0xff, 0x00}, //[15:8]address high byte
1111 {0x163d41, 0x0f, 0x02}, //[11:8]upper bond address
1112 {0x163d48, 0xff, 0xff}, //[7:0]address low byte
1113 {0x163d49, 0xff, 0xff}, //[15:8]address low byte
1114 {0x163d4a, 0xff, 0xff}, //[7:0]address high byte
1115 {0x163d4b, 0xff, 0xff}, //[15:8]address high byte
1116 {0x163d41, 0x0f, 0x03}, //[11:8]lower bond address
1117 {0x163d48, 0xff, 0x00}, //[7:0]address low byte
1118 {0x163d49, 0xff, 0x00}, //[15:8]address low byte
1119 {0x163d4a, 0xff, 0x00}, //[7:0]address high byte
1120 {0x163d4b, 0xff, 0x00}, //[15:8]address high byte
1121 {0x163d41, 0x0f, 0x04}, //[11:8]upper bond address
1122 {0x163d48, 0xff, 0xff}, //[7:0]address low byte
1123 {0x163d49, 0xff, 0xff}, //[15:8]address low byte
1124 {0x163d4a, 0xff, 0xff}, //[7:0]address high byte
1125 {0x163d4b, 0xff, 0xff}, //[15:8]address high byte
1126 {0x163d41, 0x0f, 0x05}, //[11:8]lower bond address
1127 {0x163d48, 0xff, 0x00}, //[7:0]address low byte
1128 {0x163d49, 0xff, 0x00}, //[15:8]address low byte
1129 {0x163d4a, 0xff, 0x00}, //[7:0]address high byte
1130 {0x163d4b, 0xff, 0x00}, //[15:8]address high byte
1131 {0x163d41, 0x0f, 0x06}, //[11:8]upper bond address
1132 {0x163d48, 0xff, 0xff}, //[7:0]address low byte
1133 {0x163d49, 0xff, 0xff}, //[15:8]address low byte
1134 {0x163d4a, 0xff, 0xff}, //[7:0]address high byte
1135 {0x163d4b, 0xff, 0xff}, //[15:8]address high byte
1136 {0x163d41, 0x0f, 0x07}, //[11:8]lower bond address
1137 {0x163d48, 0xff, 0x00}, //[7:0]address low byte
1138 {0x163d49, 0xff, 0x00}, //[15:8]address low byte
1139 {0x163d4a, 0xff, 0x00}, //[7:0]address high byte
1140 {0x163d4b, 0xff, 0x00}, //[15:8]address high byte
1141 {0x163d41, 0x0f, 0x08}, //[11:8]upper bond address
1142 {0x163d48, 0xff, 0xff}, //[7:0]address low byte
1143 {0x163d49, 0xff, 0xff}, //[15:8]address low byte
1144 {0x163d4a, 0xff, 0xff}, //[7:0]address high byte
1145 {0x163d4b, 0xff, 0xff}, //[15:8]address high byte
1146 {0x163d41, 0x90, 0x90}, //[15]address_0 en
1147 //R2_1 BDMA
1148 {0x163d51, 0x0f, 0x01}, //[11:8]lower bond address
1149 {0x163d58, 0xff, 0x00}, //[7:0]address low byte
1150 {0x163d59, 0xff, 0x00}, //[15:8]address low byte
1151 {0x163d5a, 0xff, 0x00}, //[7:0]address high byte
1152 {0x163d5b, 0xff, 0x00}, //[15:8]address high byte
1153 {0x163d51, 0x0f, 0x02}, //[11:8]upper bond address
1154 {0x163d58, 0xff, 0xff}, //[7:0]address low byte
1155 {0x163d59, 0xff, 0xff}, //[15:8]address low byte
1156 {0x163d5a, 0xff, 0xff}, //[7:0]address high byte
1157 {0x163d5b, 0xff, 0xff}, //[15:8]address high byte
1158 {0x163d51, 0x0f, 0x03}, //[11:8]lower bond address
1159 {0x163d58, 0xff, 0x00}, //[7:0]address low byte
1160 {0x163d59, 0xff, 0x00}, //[15:8]address low byte
1161 {0x163d5a, 0xff, 0x00}, //[7:0]address high byte
1162 {0x163d5b, 0xff, 0x00}, //[15:8]address high byte
1163 {0x163d51, 0x0f, 0x04}, //[11:8]upper bond address
1164 {0x163d58, 0xff, 0xff}, //[7:0]address low byte
1165 {0x163d59, 0xff, 0xff}, //[15:8]address low byte
1166 {0x163d5a, 0xff, 0xff}, //[7:0]address high byte
1167 {0x163d5b, 0xff, 0xff}, //[15:8]address high byte
1168 {0x163d51, 0x0f, 0x05}, //[11:8]lower bond address
1169 {0x163d58, 0xff, 0x00}, //[7:0]address low byte
1170 {0x163d59, 0xff, 0x00}, //[15:8]address low byte
1171 {0x163d5a, 0xff, 0x00}, //[7:0]address high byte
1172 {0x163d5b, 0xff, 0x00}, //[15:8]address high byte
1173 {0x163d51, 0x0f, 0x06}, //[11:8]upper bond address
1174 {0x163d58, 0xff, 0xff}, //[7:0]address low byte
1175 {0x163d59, 0xff, 0xff}, //[15:8]address low byte
1176 {0x163d5a, 0xff, 0xff}, //[7:0]address high byte
1177 {0x163d5b, 0xff, 0xff}, //[15:8]address high byte
1178 {0x163d51, 0x0f, 0x07}, //[11:8]lower bond address
1179 {0x163d58, 0xff, 0x00}, //[7:0]address low byte
1180 {0x163d59, 0xff, 0x00}, //[15:8]address low byte
1181 {0x163d5a, 0xff, 0x00}, //[7:0]address high byte
1182 {0x163d5b, 0xff, 0x00}, //[15:8]address high byte
1183 {0x163d51, 0x0f, 0x08}, //[11:8]upper bond address
1184 {0x163d58, 0xff, 0xff}, //[7:0]address low byte
1185 {0x163d59, 0xff, 0xff}, //[15:8]address low byte
1186 {0x163d5a, 0xff, 0xff}, //[7:0]address high byte
1187 {0x163d5b, 0xff, 0xff}, //[15:8]address high byte
1188 {0x163d51, 0x90, 0x90}, //[15]address_0 en
1189 #endif
1190
1191 {0xFFFFFF, 0x00, 0x00}, // end of table
1192 };
1193
1194 const AUDIO_REG_TYPE AudioInitTbl_1[]=
1195 {
1196 // ----------------------------------------------------
1197 // sound effect init settings
1198 //-----------------------------------------------------
1199 {0x112D01, 0xFF, 0x8C}, // AUOUT0 volume : 0dB ; Mute @@VVV
1200 {0x112D03, 0xFF, 0x8C}, // AUOUT1 volume : 0dB ; Mute @@VVV
1201 {0x112D05, 0xFF, 0x8C}, // AUOUT2 volume : 0dB ; Mute @@VVV
1202 {0x112D07, 0xFF, 0x8C}, // AUOUT3 volume : 0dB ; Mute @@VVV
1203 {0x112D09, 0xFF, 0x8C}, // I2S_OUT volume : 0dB ; Mute @@VVV
1204 {0x112D0B, 0xFF, 0x0C}, // SPDIF_OUT volume : 0dB ; UnMute @@VVV
1205 // if spdif change to mute, need set g_SPDIF_MuteStatus = 1;
1206 {0x112D0F, 0xFF, 0x0C}, // HDMI_OUT volume : 0dB ; UnMute @@VVV
1207
1208 {0x112D20, 0x80, 0x00}, // Disable EQ @@VVV
1209 {0x112D21, 0xFF, 0xC8}, // Enable Sound effect & tone @@VVV
1210 {0x112D22, 0x3F, 0x3F}, // Enable all output Volume control @@VVV
1211 {0x112D23, 0x01, 0x01}, // Enable SPDIF_OUT volume control @@VVV
1212 {0x112D31, 0x02, 0x00}, // disable SE-DSP power-down command @@VVV
1213 {0x112D50, 0xFF, 0xFF}, // DAC0/1 source default in NULL path @@VVV
1214 {0x112D51, 0xFF, 0xFF}, // DAC2/3 source default in NULL path @@VVV
1215 {0x112D52, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
1216 {0x112D53, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
1217 {0x112D54, 0xF0, 0x40}, // SRC source from PCM @@VVV
1218
1219 {0x112D5D, 0xFF, 0x0C}, // set mix volume of CH5, CH6, CH8 to 0dB
1220 {0x112D5C, 0xFF, 0x00},
1221 {0x112D5F, 0xFF, 0x0C},
1222 {0x112D5E, 0xFF, 0x00},
1223 {0x112D5B, 0xFF, 0x0C},
1224 {0x112D5A, 0xFF, 0x00},
1225
1226 //---------------REG_AUDIO_DECIMATION_CFG--------------------------//
1227 {0x112C58, 0x04, 0x04}, // AUDIO_HDMI_OUTPUT decimation mode always on
1228
1229 {0x112C05, 0x01, 0x01}, // dummy reg to check audio init is done
1230
1231 {0xFFFFFF, 0x00, 0x00}, // end of table
1232 };
1233
1234 const AUDIO_REG_TYPE2 ResetDMIOTbl[]=
1235 {
1236 //DMIO a0xx reset
1237 {0x112A80 , 0xFFFF, 0x0040},
1238 {0x112A80 , 0xFFFF, 0x0043},
1239 {0x112a84 , 0xFFFF, 0xa05a},
1240 {0x112a82 , 0xFFFF, 0x0000},
1241 {0x112a82 , 0xFFFF, 0x0080},
1242
1243 {0x112A80 , 0xFFFF, 0x0053},
1244 {0x112A80 , 0xFFFF, 0x0043},
1245 {0x112a84 , 0xFFFF, 0xa05e},
1246 {0x112a82 , 0xFFFF, 0x0000},
1247 {0x112a82 , 0xFFFF, 0x0080},
1248
1249 {0x112a80 , 0xFFFF, 0x0053},
1250 {0x112a80 , 0xFFFF, 0x0043},
1251 {0x112a84 , 0xFFFF, 0xa062},
1252 {0x112a82 , 0xFFFF, 0x0000},
1253 {0x112a82 , 0xFFFF, 0x0080},
1254
1255 {0x112a80 , 0xFFFF, 0x0053},
1256 {0x112a80 , 0xFFFF, 0x0043},
1257 {0x112a84 , 0xFFFF, 0xa066},
1258 {0x112a82 , 0xFFFF, 0x0000},
1259 {0x112a82 , 0xFFFF, 0x0080},
1260
1261 {0x112a80 , 0xFFFF, 0x0053},
1262 {0x112a80 , 0xFFFF, 0x0043},
1263 {0x112a84 , 0xFFFF, 0xa06a},
1264 {0x112a82 , 0xFFFF, 0x0000},
1265 {0x112a82 , 0xFFFF, 0x0080},
1266
1267 {0x112a80 , 0xFFFF, 0x0053},
1268 {0x112a80 , 0xFFFF, 0x0043},
1269 {0x112a84 , 0xFFFF, 0xa06e},
1270 {0x112a82 , 0xFFFF, 0x0000},
1271 {0x112a82 , 0xFFFF, 0x0080},
1272
1273 {0x112a80 , 0xFFFF, 0x0053},
1274 {0x112a80 , 0xFFFF, 0x0043},
1275 {0x112a84 , 0xFFFF, 0xa072},
1276 {0x112a82 , 0xFFFF, 0x0000},
1277 {0x112a82 , 0xFFFF, 0x0080},
1278
1279 {0x112a80 , 0xFFFF, 0x0053},
1280 {0x112a80 , 0xFFFF, 0x0043},
1281 {0x112a84 , 0xFFFF, 0xa076},
1282 {0x112a82 , 0xFFFF, 0x0000},
1283 {0x112a82 , 0xFFFF, 0x0080},
1284
1285 {0x112a80 , 0xFFFF, 0x0053},
1286 {0x112a80 , 0xFFFF, 0x0043},
1287 {0x112a84 , 0xFFFF, 0xa07a},
1288 {0x112a82 , 0xFFFF, 0x0000},
1289 {0x112a82 , 0xFFFF, 0x0080},
1290
1291 {0x112a80 , 0xFFFF, 0x0053},
1292 {0x112a80 , 0xFFFF, 0x0043},
1293 {0x112a84 , 0xFFFF, 0xa07e},
1294 {0x112a82 , 0xFFFF, 0x0000},
1295 {0x112a82 , 0xFFFF, 0x0080},
1296
1297 {0x112a80 , 0xFFFF, 0x0053},
1298 {0x112a80 , 0xFFFF, 0x0043},
1299 {0x112a84 , 0xFFFF, 0xa082},
1300 {0x112a82 , 0xFFFF, 0x0000},
1301 {0x112a82 , 0xFFFF, 0x0080},
1302
1303 {0x112a80 , 0xFFFF, 0x0053},
1304 {0x112a80 , 0xFFFF, 0x0043},
1305 {0x112a84 , 0xFFFF, 0xa086},
1306 {0x112a82 , 0xFFFF, 0x0000},
1307 {0x112a82 , 0xFFFF, 0x0080},
1308
1309 {0x112a80 , 0xFFFF, 0x0053},
1310 {0x112a80 , 0xFFFF, 0x0043},
1311 {0x112a84 , 0xFFFF, 0xa08a},
1312 {0x112a82 , 0xFFFF, 0x0000},
1313 {0x112a82 , 0xFFFF, 0x0080},
1314
1315 {0x112a80 , 0xFFFF, 0x0053},
1316 {0x112a80 , 0xFFFF, 0x0043},
1317 {0x112a84 , 0xFFFF, 0xa0b5},
1318 {0x112a82 , 0xFFFF, 0x0000},
1319 {0x112a82 , 0xFFFF, 0x0080},
1320
1321 {0x112a80 , 0xFFFF, 0x0053},
1322 {0x112a80 , 0xFFFF, 0x0043},
1323 {0x112a84 , 0xFFFF, 0xa0e0},
1324 {0x112a82 , 0xFFFF, 0x0000},
1325 {0x112a82 , 0xFFFF, 0x0080},
1326
1327 {0x112a80 , 0xFFFF, 0x0053},
1328 {0x112a80 , 0xFFFF, 0x0043},
1329 {0x112a84 , 0xFFFF, 0xa17a},
1330 {0x112a82 , 0xFFFF, 0x0000},
1331 {0x112a82 , 0xFFFF, 0x0080},
1332
1333 {0x112a80 , 0xFFFF, 0x0053},
1334 {0x112a80 , 0xFFFF, 0x0043},
1335 {0x112a84 , 0xFFFF, 0xa17e},
1336 {0x112a82 , 0xFFFF, 0x0000},
1337 {0x112a82 , 0xFFFF, 0x0080},
1338
1339 {0x112a80 , 0xFFFF, 0x0053},
1340 {0x112a80 , 0xFFFF, 0x0043},
1341 {0x112a84 , 0xFFFF, 0xa182},
1342 {0x112a82 , 0xFFFF, 0x0000},
1343 {0x112a82 , 0xFFFF, 0x0080},
1344
1345 {0x112a80 , 0xFFFF, 0x0053},
1346 {0x112a80 , 0xFFFF, 0x0043},
1347 {0x112a84 , 0xFFFF, 0xa186},
1348 {0x112a82 , 0xFFFF, 0x0000},
1349 {0x112a82 , 0xFFFF, 0x0080},
1350
1351 {0x112a80 , 0xFFFF, 0x0053},
1352 {0x112a80 , 0xFFFF, 0x0043},
1353 {0x112a84 , 0xFFFF, 0xa18a},
1354 {0x112a82 , 0xFFFF, 0x0000},
1355 {0x112a82 , 0xFFFF, 0x0080},
1356
1357 {0x112a80 , 0xFFFF, 0x0053},
1358 {0x112a80 , 0xFFFF, 0x0043},
1359 {0x112a84 , 0xFFFF, 0xa176},
1360 {0x112a82 , 0xFFFF, 0x0000},
1361 {0x112a82 , 0xFFFF, 0x0080},
1362
1363 {0x112a80 , 0xFFFF, 0x0053},
1364 {0x112a80 , 0xFFFF, 0x0043},
1365 {0x112a84 , 0xFFFF, 0xa1e0},
1366 {0x112a82 , 0xFFFF, 0x0000},
1367 {0x112a82 , 0xFFFF, 0x0080},
1368
1369 {0x112a80 , 0xFFFF, 0x0053},
1370 {0x112a80 , 0xFFFF, 0x0043},
1371 {0x112a84 , 0xFFFF, 0xa1e8},
1372 {0x112a82 , 0xFFFF, 0x0000},
1373 {0x112a82 , 0xFFFF, 0x0080},
1374
1375 {0x112a80 , 0xFFFF, 0x0053},
1376 {0x112a80 , 0xFFFF, 0x0043},
1377 {0x112a80 , 0xFFFF, 0x0000},
1378 {0x112c00 , 0xFFFF, 0x0101},
1379 {0x112c00 , 0xFFFF, 0x0000},
1380
1381 //end DMIO a0xx reset
1382 {0xFFFFFF, 0x0000, 0x0000}, // end of table
1383
1384 };
1385
1386 const AUDIO_REG_TYPE Audio_stopDecTbl[] =
1387 {
1388 {0x160399 , 0xFF, 0x00}, // DEC R2(2R)
1389 {0x16039b , 0xFF, 0x00},
1390 {0x112e99 , 0xFF, 0x00}, // DEC R2(1R)
1391 {0x112e9b , 0xFF, 0x00},
1392 {0x112a2c , 0xFF, 0x00}, // DEC DSP
1393 {0x112aac , 0xFF, 0x00}, // SE DSP
1394
1395 {0xFFFFFF , 0x00, 0x00}, // end of table
1396 };
1397
1398 #if AUDIO_HW_DMA_READER1_SUPPORT
1399 AUDIO_PCM_t Audio_Pcm_HwDma_Reader1 = {
1400 .u8Name = AUDIO_HW_DMA_READER1,
1401 .tPcmOps = {
1402 .open = HAL_AUDIO_PCM_HwDma_Reader1_Open,
1403 .close = HAL_AUDIO_PCM_HwDma_Reader1_Close,
1404 .start = HAL_AUDIO_PCM_HwDma_Reader1_Start,
1405 .stop = HAL_AUDIO_PCM_HwDma_Reader1_Stop,
1406 .set = HAL_AUDIO_PCM_HwDma_Reader1_Set,
1407 .get = HAL_AUDIO_PCM_HwDma_Reader1_Get,
1408 .read = NULL,
1409 .write = HAL_AUDIO_PCM_HwDma_Reader1_Write,
1410 .flush = HAL_AUDIO_PCM_HwDma_Reader1_Flush,
1411 },
1412 .tPcmCaps = {
1413 .u8MultiChFlag = FALSE,
1414 .u8MixingFlag = FALSE,
1415 .u8CaptureFlag = FALSE,
1416 .u32Channel = {1, 2},
1417 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1418 .u32BitWidth = {16},
1419 },
1420 };
1421 #endif
1422
1423 #if AUDIO_HW_DMA_READER2_SUPPORT
1424 AUDIO_PCM_t Audio_Pcm_HwDma_Reader2 = {
1425 .u8Name = AUDIO_HW_DMA_READER2,
1426 .tPcmOps = {
1427 .open = HAL_AUDIO_PCM_HwDma_Reader2_Open,
1428 .close = HAL_AUDIO_PCM_HwDma_Reader2_Close,
1429 .start = HAL_AUDIO_PCM_HwDma_Reader2_Start,
1430 .stop = HAL_AUDIO_PCM_HwDma_Reader2_Stop,
1431 .set = HAL_AUDIO_PCM_HwDma_Reader2_Set,
1432 .get = HAL_AUDIO_PCM_HwDma_Reader2_Get,
1433 .read = NULL,
1434 .write = HAL_AUDIO_PCM_HwDma_Reader2_Write,
1435 .flush = HAL_AUDIO_PCM_HwDma_Reader2_Flush,
1436 },
1437 .tPcmCaps = {
1438 .u8MultiChFlag = FALSE,
1439 .u8MixingFlag = FALSE,
1440 .u8CaptureFlag = FALSE,
1441 .u32Channel = {1, 2},
1442 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1443 .u32BitWidth = {16},
1444 },
1445 };
1446 #endif
1447
1448 #if AUDIO_SW_DMA_READER1_SUPPORT
1449 AUDIO_PCM_t Audio_Pcm_SwDma_Reader1 = {
1450 .u8Name = AUDIO_SW_DMA_READER1,
1451 .tPcmOps = {
1452 .open = HAL_AUDIO_PCM_SwDma_Reader1_Open,
1453 .close = HAL_AUDIO_PCM_SwDma_Reader1_Close,
1454 .start = HAL_AUDIO_PCM_SwDma_Reader1_Start,
1455 .stop = HAL_AUDIO_PCM_SwDma_Reader1_Stop,
1456 .set = HAL_AUDIO_PCM_SwDma_Reader1_Set,
1457 .get = HAL_AUDIO_PCM_SwDma_Reader1_Get,
1458 .read = NULL,
1459 .write = HAL_AUDIO_PCM_SwDma_Reader1_Write,
1460 .flush = HAL_AUDIO_PCM_SwDma_Reader1_Flush,
1461 },
1462 .tPcmCaps = {
1463 .u8MultiChFlag = FALSE,
1464 .u8MixingFlag = FALSE,
1465 .u8CaptureFlag = FALSE,
1466 .u32Channel = {1, 2},
1467 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
1468 .u32BitWidth = {16},
1469 },
1470 };
1471 #endif
1472
1473 #if AUDIO_R2_DMA_READER1_SUPPORT
1474 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader1 = {
1475 .u8Name = AUDIO_R2_DMA_READER1,
1476 .tPcmOps = {
1477 .open = HAL_AUDIO_PCM_R2Dma_Reader1_Open,
1478 .close = HAL_AUDIO_PCM_R2Dma_Reader1_Close,
1479 .start = HAL_AUDIO_PCM_R2Dma_Reader1_Start,
1480 .stop = HAL_AUDIO_PCM_R2Dma_Reader1_Stop,
1481 .set = HAL_AUDIO_PCM_R2Dma_Reader1_Set,
1482 .get = HAL_AUDIO_PCM_R2Dma_Reader1_Get,
1483 .read = NULL,
1484 .write = HAL_AUDIO_PCM_R2Dma_Reader1_Write,
1485 .flush = HAL_AUDIO_PCM_R2Dma_Reader1_Flush,
1486 },
1487 .tPcmCaps = {
1488 .u8MultiChFlag = TRUE,
1489 .u8MixingFlag = FALSE,
1490 .u8CaptureFlag = FALSE,
1491 .u32Channel = {1, 2, 10},
1492 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1493 .u32BitWidth = {16},
1494 },
1495 };
1496 #endif
1497
1498 #if AUDIO_R2_DMA_READER2_SUPPORT
1499 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader2 = {
1500 .u8Name = AUDIO_R2_DMA_READER2,
1501 .tPcmOps = {
1502 .open = HAL_AUDIO_PCM_R2Dma_Reader2_Open,
1503 .close = HAL_AUDIO_PCM_R2Dma_Reader2_Close,
1504 .start = HAL_AUDIO_PCM_R2Dma_Reader2_Start,
1505 .stop = HAL_AUDIO_PCM_R2Dma_Reader2_Stop,
1506 .set = HAL_AUDIO_PCM_R2Dma_Reader2_Set,
1507 .get = HAL_AUDIO_PCM_R2Dma_Reader2_Get,
1508 .read = NULL,
1509 .write = HAL_AUDIO_PCM_R2Dma_Reader2_Write,
1510 .flush = HAL_AUDIO_PCM_R2Dma_Reader2_Flush,
1511 },
1512 .tPcmCaps = {
1513 .u8MultiChFlag = TRUE,
1514 .u8MixingFlag = FALSE,
1515 .u8CaptureFlag = FALSE,
1516 .u32Channel = {1, 2, 10},
1517 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1518 .u32BitWidth = {16},
1519 },
1520 };
1521 #endif
1522
1523 #if AUDIO_PCM_CAPTURE1_SUPPORT
1524 AUDIO_PCM_t Audio_Pcm_Capture1 = {
1525 .u8Name = AUDIO_PCM_CAPTURE1,
1526 .tPcmOps = {
1527 .open = HAL_AUDIO_PCM_Capture1_Open,
1528 .close = HAL_AUDIO_PCM_Capture1_Close,
1529 .start = HAL_AUDIO_PCM_Capture1_Start,
1530 .stop = HAL_AUDIO_PCM_Capture1_Stop,
1531 .set = HAL_AUDIO_PCM_Capture1_Set,
1532 .get = HAL_AUDIO_PCM_Capture1_Get,
1533 .read = HAL_AUDIO_PCM_Capture1_Read,
1534 .write = NULL,
1535 .flush = HAL_AUDIO_PCM_Capture1_Flush,
1536 },
1537 .tPcmCaps = {
1538 .u8MultiChFlag = FALSE,
1539 .u8MixingFlag = FALSE,
1540 .u8CaptureFlag = TRUE,
1541 .u32Channel = {2},
1542 .u32SampleRate = {48000},
1543 .u32BitWidth = {16},
1544 },
1545 };
1546 #endif
1547
1548 #if AUDIO_PCM_CAPTURE2_SUPPORT
1549 AUDIO_PCM_t Audio_Pcm_Capture2 = {
1550 .u8Name = AUDIO_PCM_CAPTURE2,
1551 .tPcmOps = {
1552 .open = HAL_AUDIO_PCM_Capture2_Open,
1553 .close = HAL_AUDIO_PCM_Capture2_Close,
1554 .start = HAL_AUDIO_PCM_Capture2_Start,
1555 .stop = HAL_AUDIO_PCM_Capture2_Stop,
1556 .set = HAL_AUDIO_PCM_Capture2_Set,
1557 .get = HAL_AUDIO_PCM_Capture2_Get,
1558 .read = HAL_AUDIO_PCM_Capture2_Read,
1559 .write = NULL,
1560 .flush = HAL_AUDIO_PCM_Capture2_Flush,
1561 },
1562 .tPcmCaps = {
1563 .u8MultiChFlag = FALSE,
1564 .u8MixingFlag = FALSE,
1565 .u8CaptureFlag = TRUE,
1566 .u32Channel = {2},
1567 .u32SampleRate = {48000},
1568 .u32BitWidth = {16},
1569 },
1570 };
1571 #endif
1572
1573 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1574 AUDIO_PCM_t Audio_Pcm_HwDma_Writer1 = {
1575 .u8Name = AUDIO_HW_DMA_WRITER1,
1576 .tPcmOps = {
1577 .open = HAL_AUDIO_PCM_HwDma_Writer1_Open,
1578 .close = HAL_AUDIO_PCM_HwDma_Writer1_Close,
1579 .start = HAL_AUDIO_PCM_HwDma_Writer1_Start,
1580 .stop = HAL_AUDIO_PCM_HwDma_Writer1_Stop,
1581 .set = HAL_AUDIO_PCM_HwDma_Writer1_Set,
1582 .get = HAL_AUDIO_PCM_HwDma_Writer1_Get,
1583 .read = HAL_AUDIO_PCM_HwDma_Writer1_Read,
1584 .write = NULL,
1585 .flush = HAL_AUDIO_PCM_HwDma_Writer1_Flush,
1586 },
1587 .tPcmCaps = {
1588 .u8MultiChFlag = FALSE,
1589 .u8MixingFlag = FALSE,
1590 .u8CaptureFlag = TRUE,
1591 .u32Channel = {2},
1592 .u32SampleRate = {48000},
1593 .u32BitWidth = {16},
1594 },
1595 };
1596 #endif
1597
1598 MS_U8 g_Common_PCM_IO_Init = FALSE;
1599
1600 AUDIO_PCM_t *g_PCM[AUDIO_PCM_MAXNUM] = {
1601 #if AUDIO_HW_DMA_READER1_SUPPORT
1602 &Audio_Pcm_HwDma_Reader1,
1603 #endif
1604 #if AUDIO_HW_DMA_READER2_SUPPORT
1605 &Audio_Pcm_HwDma_Reader2,
1606 #endif
1607 #if AUDIO_SW_DMA_READER1_SUPPORT
1608 &Audio_Pcm_SwDma_Reader1,
1609 #endif
1610 #if AUDIO_R2_DMA_READER1_SUPPORT
1611 &Audio_Pcm_R2Dma_Reader1,
1612 #endif
1613 #if AUDIO_R2_DMA_READER2_SUPPORT
1614 &Audio_Pcm_R2Dma_Reader2,
1615 #endif
1616 #if AUDIO_PCM_CAPTURE1_SUPPORT
1617 &Audio_Pcm_Capture1,
1618 #endif
1619 #if AUDIO_PCM_CAPTURE2_SUPPORT
1620 &Audio_Pcm_Capture2,
1621 #endif
1622 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1623 &Audio_Pcm_HwDma_Writer1,
1624 #endif
1625 };
1626
1627 #if AUDIO_MP3_ENCODER1_SUPPORT
1628 static MS_U32 g_u32Mp3Encoder1RptrOffset = 0;
1629 #endif
1630
1631 #if AUDIO_MP3_ENCODER2_SUPPORT
1632 static MS_U32 g_u32Mp3Encoder2RptrOffset = 0;
1633 #endif
1634
1635
1636 //-------------------------------------------------------------------------------------------------
1637 // Debug Functions
1638 //-------------------------------------------------------------------------------------------------
1639
1640 //-------------------------------------------------------------------------------------------------
1641 // Local Functions
1642 //-------------------------------------------------------------------------------------------------
1643
1644 ////////////////////////////////////////////////////////////////////////////////
1645 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus()
1646 /// @brief \b Function \b Description: Return audio status.
1647 /// @return MS_U16 \b : return structure which include pcm, non pcm, sampling rate.
1648 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus(ST_HDMI_AUDIO_STATUS * p_hdmiAudioSts)1649 MS_BOOL HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus( ST_HDMI_AUDIO_STATUS *p_hdmiAudioSts)
1650 {
1651 MS_BOOL ret = true;
1652
1653 if (HAL_AUDIO_HDMI_NonpcmMonitor())
1654 {
1655 switch(HAL_AUDIO_HDMI_DolbyMonitor())
1656 {
1657 case 0x01: p_hdmiAudioSts->audio_type = HDMI_RX_DD; break;
1658 case 0x0b: p_hdmiAudioSts->audio_type = HDMI_RX_DTS; break;
1659 case 0x15: p_hdmiAudioSts->audio_type = HDMI_RX_DDP; break;
1660 default: p_hdmiAudioSts->audio_type = HDMI_RX_Other; break;
1661 }
1662 }
1663 else
1664 p_hdmiAudioSts->audio_type = HDMI_RX_PCM;
1665
1666 return ret;
1667
1668 }
1669
HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)1670 MS_BOOL HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)
1671 {
1672 MS_U8 i = 0;
1673 MS_U8 array_mount = 0;
1674
1675 if (pAUDIOShared == NULL)
1676 {
1677 return FALSE;
1678 }
1679
1680 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1681
1682 /* Fill in default value */
1683 pAUDIOShared->g_DspCodeType = AU_DVB_STANDARD_INVALID;
1684 pAUDIOShared->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
1685 pAUDIOShared->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
1686 pAUDIOShared->g_u8DspAliveFlag = TRUE;
1687 pAUDIOShared->g_eSpdifOutputType = SPDIF_OUT_NONE;
1688 pAUDIOShared->g_SpdifNpcmPath = AUDIO_DSP_ID_ALL;
1689
1690 pAUDIOShared->g_u8SifDspType = DSP_SE;
1691
1692
1693 array_mount = sizeof(pAUDIOShared->sif_gain_0) / sizeof(pAUDIOShared->sif_gain_0[0]);
1694 for (i = 0; i < array_mount; i++)
1695 {
1696 /* Note! sif_gain_0[] is expected same length as sif_shift_0[] */
1697 pAUDIOShared->sif_gain_0[i] = 0x7FFF;
1698 pAUDIOShared->sif_shift_0[i] = 0x0000;
1699 }
1700 pAUDIOShared->g_u8IntTag = 1;
1701 pAUDIOShared->int_mb_cnt = 0;
1702
1703 pAUDIOShared->CompressInfo = 0;
1704 for ( i = 0; i < MAX_AUDIO_BASE_ADDRESS_NUM2; i++ )
1705 {
1706 pAUDIOShared->g_DSPMadMIUBank[i] = g_DSPMadMIUBank[i];
1707 pAUDIOShared->g_DSPBinBaseAddress[i] = g_DSPBinBaseAddress[i];
1708 pAUDIOShared->g_DSPMadBaseBufferAdr[i] = g_DSPMadBaseBufferAdr[i];
1709 pAUDIOShared->g_DSPDDRBinBaseAddress[i] = g_DSPDDRBinBaseAddress[i];
1710 }
1711
1712 pAUDIOShared->eMainSourceType = E_AUDIO_INFO_DTV_IN;
1713 pAUDIOShared->ePrevSourceType = E_AUDIO_INFO_DTV_IN;
1714 for ( i = 0; i < AU_DEC_MAX; i++ )
1715 {
1716 pAUDIOShared->DspUsage[i].bDecInUsed = FALSE;
1717 pAUDIOShared->DspUsage[i].eAudioType = Audio_DEC_NULL;
1718 pAUDIOShared->DspUsage[i].eUsageType = AUDIO_USAGE_TYPE_NONE;
1719 }
1720
1721 pAUDIOShared->eAudioSource = E_AUDIO_INFO_ADC_IN;
1722 pAUDIOShared->eMainAudioSource = AUDIO_NULL_INPUT;
1723 pAUDIOShared->eSubAudioSource = AUDIO_NULL_INPUT;
1724 pAUDIOShared->eScartAudioSource = AUDIO_NULL_INPUT;
1725
1726 pAUDIOShared->g_SPDIF_MuteStatus = 0;
1727
1728 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1729 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8R2NonPcmSetting = 0x00;
1730 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1731 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1732
1733 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1734 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8R2NonPcmSetting = 0x00;
1735 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1736 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1737
1738 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1739 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8R2NonPcmSetting = 0x00;
1740 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1741 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1742
1743 pAUDIOShared->g_dolbyLoudness_DTVsystem = DVB_MODE;
1744 pAUDIOShared->g_dolbyLoudness_Enable = 1;
1745
1746 /* 1st decoder (depends on chip) */
1747 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsVersion = AUD_CAP_VERSION;
1748 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1749 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum = 2;
1750 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDmaReaderNum = 2;
1751 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsADSupported = TRUE;
1752 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsPusiDetectSupported = FALSE;
1753 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMpegSupported = TRUE;
1754 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3Supported = TRUE;
1755 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3pSupported = TRUE;
1756 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAacSupported = TRUE;
1757 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMp3Supported = TRUE;
1758 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaSupported = TRUE;
1759 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsRa8LbrSupported = TRUE;
1760 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsXpcmSupported = TRUE;
1761 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsSupported = TRUE;
1762 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaProSupported = TRUE;
1763 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsFlacSupported = TRUE;
1764 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsVorbisSupported = TRUE;
1765 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsLbrSupported = TRUE;
1766 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrNbSupported = TRUE;
1767 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrWbSupported = TRUE;
1768 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDraSupported = TRUE;
1769
1770 /* 2nd decoder (depends on chip) */
1771 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsVersion = AUD_CAP_VERSION;
1772 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1773 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDecoderNum = 2;
1774 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDmaReaderNum = 2;
1775 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsADSupported = TRUE;
1776 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsPusiDetectSupported = FALSE;
1777 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMpegSupported = TRUE;
1778 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3Supported = TRUE;
1779 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3pSupported = TRUE;
1780 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAacSupported = TRUE;
1781 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMp3Supported = TRUE;
1782 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaSupported = TRUE;
1783 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsRa8LbrSupported = TRUE;
1784 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsXpcmSupported = TRUE;
1785 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsSupported = TRUE;
1786 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaProSupported = TRUE;
1787 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsFlacSupported = TRUE;
1788 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsVorbisSupported = TRUE;
1789 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsLbrSupported = TRUE;
1790 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrNbSupported = TRUE;
1791 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrWbSupported = TRUE;
1792 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDraSupported = TRUE;
1793
1794 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructVersion = AUDIO_OUTPUT_DEVICE_SELECTION_VERSION;
1795 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructSize = sizeof(AUDIO_OUTPUT_DEVICE_SELECTION_t);
1796
1797 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructVersion = AUDIO_SPECIFIED_DIGITAL_OUTPUT_VERSION;
1798 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructSize = sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t);
1799
1800 pAUDIOShared->g_SPDIF_MuteStatus = 0;
1801
1802 pAUDIOShared->g_hbr_bypass_enable = FALSE;
1803
1804 //pAUDIOShared->AudioSrcType = AUDIO_DSP1_DVB_INPUT;
1805 //pAUDIOShared->AudioSubSrcType = AUDIO_DSP1_DVB_INPUT;
1806
1807 return TRUE;
1808 }
1809
HAL_AUDIO_AllocateVars(void)1810 AUDIO_SHARED_VARS2 * HAL_AUDIO_AllocateVars(void)
1811 {
1812 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1813
1814 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1815 MS_U32 u32ShmId = 0;
1816 AUDIO_SHARED_VARS2 *virtAddr = 0;
1817 MS_U32 u32BufSize = 0;
1818
1819 HALAUDIO_ERROR("Start %s InitShmFlag=%d\r\n", __FUNCTION__, g_bInitShmFlag);
1820
1821 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
1822 {
1823 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1824
1825 HALAUDIO_ERROR("%s QUERY ClientCounter=%u\r\n", __FUNCTION__, pAUDIOShared->g_u32ClientCounter);
1826
1827 if (pAUDIOShared->g_u32ClientCounter == 0)
1828 {
1829 HALAUDIO_ERROR("Resume from Suspend mode, reset Audio SHM data ...\n");
1830 }
1831 }
1832 else
1833 {
1834 HALAUDIO_ERROR("create Audio SHM data ...\n");
1835
1836 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
1837 {
1838 HALAUDIO_ERROR("Audio SHM data is created\n");
1839 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1840
1841 HALAUDIO_ERROR("reset Audio SHM data ...\n");
1842 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1843 }
1844 else
1845 {
1846 HALAUDIO_ERROR("AUDIO SHM allocation failed!\n");
1847 return NULL;
1848 }
1849 }
1850
1851 if (g_bInitShmFlag == FALSE)
1852 {
1853 g_bInitShmFlag = TRUE;
1854 pAUDIOShared->g_u32ClientCounter++;
1855 }
1856
1857 HALAUDIO_ERROR("End %s InitShmFlag=%d, ClientCounter=%u \r\n", __FUNCTION__, g_bInitShmFlag, pAUDIOShared->g_u32ClientCounter);
1858
1859 #else
1860 pAUDIOShared = &g_audioShared;
1861
1862 if (g_bInitShmFlag == FALSE)
1863 {
1864 HALAUDIO_PRINT("create Audio SHM data ...\n");
1865 g_bInitShmFlag = TRUE;
1866
1867 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1868
1869 pAUDIOShared->g_u32ClientCounter++;
1870 }
1871 #endif
1872 gOpenDecodeSystemFuncPtr = HAL_AUDIO_OpenDecodeSystem;
1873 gDigitalOutChannelStatusFuncPtr = HAL_AUDIO_DigitalOut_SetChannelStatus;
1874 pFuncPtr_Setsystem = HAL_AUDIO_SetDecodeSystem;
1875 gGetDDRInfoFuncPtr = HAL_AUDIO_GetDDRInfo;
1876
1877 return pAUDIOShared;
1878 }
1879
HAL_AUDIO_DeAllocateVars(void)1880 MS_BOOL HAL_AUDIO_DeAllocateVars(void)
1881 {
1882 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1883
1884 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1885 MS_U32 u32ShmId = 0;
1886 AUDIO_SHARED_VARS2 *virtAddr = 0;
1887 MS_U32 u32BufSize = 0;
1888
1889 HALAUDIO_ERROR("Start HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1890
1891 if (g_bInitShmFlag == TRUE)
1892 {
1893 g_bInitShmFlag = FALSE;
1894
1895 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
1896 {
1897 HALAUDIO_ERROR("%s() : No AUDIO SHM is created!\n", __FUNCTION__);
1898 return FALSE;
1899 }
1900
1901 pAUDIOShared = (AUDIO_SHARED_VARS2 *)virtAddr;
1902 pAUDIOShared->g_u32ClientCounter--;
1903
1904 HALAUDIO_ERROR("HAL_AUDIO_DeAllocateVars ClientCounter=%u\r\n", pAUDIOShared->g_u32ClientCounter);
1905
1906 if (pAUDIOShared->g_u32ClientCounter == 0)
1907 {
1908 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1909
1910 HALAUDIO_ERROR("free Audio SHM data ...\n");
1911 #if defined(MSOS_TYPE_LINUX)
1912 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_SHM_NAME, u32ShmId) == TRUE)
1913 {
1914 HALAUDIO_ERROR("Audio SHM data is freed\n");
1915 }
1916 else
1917 {
1918 HALAUDIO_ERROR("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1919 return FALSE;
1920 }
1921 #endif
1922
1923 HAL_AUDIO_Mutex_DeInit();
1924 }
1925 /* patch for DC off/on no sound issue start */
1926 else
1927 {
1928 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1929 }
1930 /* patch for DC off/on no sound issue end */
1931 }
1932
1933 HALAUDIO_ERROR("End HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1934 #else
1935 pAUDIOShared = &g_audioShared;
1936
1937 if (g_bInitShmFlag == TRUE)
1938 {
1939 HALAUDIO_PRINT("free Audio SHM data ...\n");
1940 g_bInitShmFlag = FALSE;
1941
1942 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1943 }
1944 #endif
1945
1946 return TRUE;
1947 }
1948
1949 ////////////////////////////////////////////////////////////////////////////////
1950 /// @brief \b Function \b Name: HAL_AUDIO_InitialVars()
1951 /// @brief \b Function \b Description: This routine set audio share memory of Aduio module.
1952 /// @param <IN> \b NONE :
1953 /// @param <OUT> \b NONE :
1954 /// @param <RET> \b NONE :
1955 /// @param <GLOBAL> \b NONE :
1956 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_InitialVars(void)1957 MS_BOOL HAL_AUDIO_InitialVars(void)
1958 {
1959 if (HAL_AUDIO_GET_INIT_FLAG() == FALSE)
1960 {
1961 g_AudioVars2 = HAL_AUDIO_AllocateVars();
1962 if (g_AudioVars2 == NULL)
1963 {
1964 return FALSE;
1965 }
1966
1967 #ifndef MSOS_TYPE_NUTTX
1968 pAudioTeeInfoShm = HAL_AUDIO_AllocateTeeInfoShm();
1969 if (pAudioTeeInfoShm == NULL)
1970 {
1971 HALAUDIO_ERROR("Create Audio TEE INFO SHM data fail...\n");
1972 return FALSE;
1973 }
1974 }
1975 #else
1976 {
1977 MS_U8 audio_mbx_class=0;
1978
1979 MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "MAD", (MS_U8 *)&audio_mbx_class);
1980 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(audio_mbx_class, 10, HAL_AUDIO_HandleDynamicMBX))
1981 {
1982 HALAUDIO_ERROR("MAD Register MBX MSG error\n");
1983 return FALSE;
1984 }
1985 else
1986 DBG_AUDIO("MAD MBX register msg ok %d\n", audio_mbx_class);
1987
1988 _s32MadEventId = MsOS_CreateEventGroup("MAD_Event");
1989 if (_s32MadEventId < 0)
1990 {
1991 HALAUDIO_ERROR("MAD CreateEventGroup error....\n");
1992 return FALSE;
1993 }
1994
1995 _s32MadTaskId = MsOS_CreateTask((TaskEntry)_MAD_Proc,
1996 NULL,
1997 E_TASK_PRI_MEDIUM,
1998 TRUE,
1999 NULL,
2000 32, // stack size..
2001 "MAD_ISR_Task");
2002 if (_s32MadTaskId < 0)
2003 {
2004 MsOS_DeleteEventGroup(_s32MadEventId);
2005 HALAUDIO_ERROR("MAD CreateTask error....\n");
2006 return FALSE;
2007 }
2008 }
2009 }
2010 #endif
2011
2012 return TRUE;
2013 }
2014
2015 ////////////////////////////////////////////////////////////////////////////////
2016 /// @brief \b Function \b Name: HAL_AUDIO_DeInitialVars()
2017 /// @brief \b Function \b Description: This routine delete audio share memory of Aduio module.
2018 /// @param <IN> \b NONE :
2019 /// @param <OUT> \b NONE :
2020 /// @param <RET> \b NONE :
2021 /// @param <GLOBAL> \b NONE :
2022 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DeInitialVars(void)2023 MS_BOOL HAL_AUDIO_DeInitialVars(void)
2024 {
2025 MS_BOOL ret = TRUE;
2026
2027 if (HAL_AUDIO_GET_INIT_FLAG() == TRUE)
2028 {
2029 HAL_AUDIO_SET_INIT_FLAG(FALSE);
2030
2031 ret = HAL_AUDIO_DeAllocateVars();
2032 if (ret == FALSE)
2033 {
2034 HALAUDIO_ERROR ("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
2035 }
2036
2037 #if 0 /* patch for STR resume segmentation fault issue */
2038 g_AudioVars2 = NULL;
2039 #endif
2040
2041 #ifndef MSOS_TYPE_NUTTX
2042 {
2043 MS_BOOL ret1;
2044
2045 ret1 = HAL_AUDIO_DeAllocateTeeInfoShm();
2046 if (ret1 == FALSE)
2047 {
2048 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
2049 ret = FALSE;
2050 }
2051 }
2052 #endif
2053 }
2054
2055 return ret;
2056 }
2057
2058 ////////////////////////////////////////////////////////////////////////////////
2059 /// @brief \b Function \b Name: HAL_AUDIO_SET_INIT_FLAG()
2060 /// @brief \b Function \b Description: This routine set the initial status of Aduio module.
2061 /// @param <IN> \b NONE :
2062 /// @param <OUT> \b NONE :
2063 /// @param <RET> \b MS_BOOL :
2064 /// @param <GLOBAL> \b NONE :
2065 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)2066 void HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)
2067 {
2068 HALAUDIO_CHECK_SHM_INIT;
2069
2070 g_AudioVars2->g_Audio_InitFlag = bSet;
2071
2072 return;
2073 }
2074
2075 ////////////////////////////////////////////////////////////////////////////////
2076 /// @brief \b Function \b Name: HAL_AUDIO_GET_INIT_FLAG()
2077 /// @brief \b Function \b Description: This routine get the initial status of Aduio module.
2078 /// @param <IN> \b NONE :
2079 /// @param <OUT> \b NONE :
2080 /// @param <RET> \b MS_BOOL :
2081 /// @param <GLOBAL> \b NONE :
2082 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GET_INIT_FLAG(void)2083 MS_BOOL HAL_AUDIO_GET_INIT_FLAG(void)
2084 {
2085 if (g_AudioVars2 == NULL)
2086 {
2087 return FALSE;
2088 }
2089
2090 return g_AudioVars2->g_Audio_InitFlag;
2091 }
2092
2093 ////////////////////////////////////////////////////////////////////////////////
2094 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_Init()
2095 /// @brief \b Function \b Description: This routine is the initialization of Mutex for Audio module.
2096 /// @param <IN> \b NONE :
2097 /// @param <OUT> \b NONE :
2098 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
2099 /// @param <GLOBAL> \b NONE :
2100 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_Init(void)2101 MS_BOOL HAL_AUDIO_Mutex_Init(void)
2102 {
2103 MS_BOOL ret = TRUE;
2104
2105 if ((_s32AUDIOMutex != -1) &&
2106 (_s32AUDIOMutexReboot != -1) &&
2107 (_s32MutexLoadCode != -1) &&
2108 (_s32AUDIOMutexIDMA != -1))
2109 {
2110 return ret;
2111 }
2112
2113 if (_s32AUDIOMutex == -1)
2114 {
2115 _s32AUDIOMutex = OS_CREATE_MUTEX(AUDIO);
2116 if (_s32AUDIOMutex == -1)
2117 {
2118 HALAUDIO_ERROR("Error! Create Mutex failed!\n");
2119 ret = FALSE;
2120 }
2121 }
2122
2123 if (_s32AUDIOMutexReboot == -1)
2124 {
2125 _s32AUDIOMutexReboot = OS_CREATE_MUTEX(AUDIOreboot);
2126 if (_s32AUDIOMutexReboot == -1)
2127 {
2128 HALAUDIO_ERROR("Error! Create Mutex for Reboot failed!\n");
2129 ret = FALSE;
2130 }
2131 }
2132
2133 if (_s32MutexLoadCode == -1)
2134 {
2135 _s32MutexLoadCode = OS_CREATE_MUTEX(LOAD_DECDSP);
2136 if (_s32MutexLoadCode == -1)
2137 {
2138 HALAUDIO_ERROR("Error! Create Mutex for Load DSP failed!\n");
2139 ret = FALSE;
2140 }
2141 }
2142
2143 if (_s32AUDIOMutexIDMA == -1)
2144 {
2145 _s32AUDIOMutexIDMA = OS_CREATE_MUTEX(AUDIO_IDMA);
2146 if (_s32AUDIOMutexIDMA == -1)
2147 {
2148 HALAUDIO_ERROR("Error! Create Mutex for IMDA failed!\n");
2149 ret = FALSE;
2150 }
2151 }
2152
2153 if (ret == FALSE)
2154 {
2155 if (_s32AUDIOMutex != -1)
2156 {
2157 OS_DELETE_MUTEX(_s32AUDIOMutex);
2158 _s32AUDIOMutex = -1;
2159 }
2160
2161 if (_s32AUDIOMutexReboot != -1)
2162 {
2163 OS_DELETE_MUTEX(_s32AUDIOMutexReboot);
2164 _s32AUDIOMutexReboot = -1;
2165 }
2166
2167 if (_s32MutexLoadCode != -1)
2168 {
2169 OS_DELETE_MUTEX(_s32MutexLoadCode);
2170 _s32MutexLoadCode = -1;
2171 }
2172
2173 if (_s32AUDIOMutexIDMA != -1)
2174 {
2175 OS_DELETE_MUTEX(_s32AUDIOMutexIDMA);
2176 _s32AUDIOMutexIDMA = -1;
2177 }
2178 }
2179
2180 return ret;
2181 }
2182
2183 ////////////////////////////////////////////////////////////////////////////////
2184 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_DeInit()
2185 /// @brief \b Function \b Description: This routine is the deletion of Mutex for Audio module.
2186 /// @param <IN> \b NONE :
2187 /// @param <OUT> \b NONE :
2188 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
2189 /// @param <GLOBAL> \b NONE :
2190 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_DeInit(void)2191 MS_BOOL HAL_AUDIO_Mutex_DeInit(void)
2192 {
2193 MS_BOOL ret = TRUE;
2194
2195 if ((_s32AUDIOMutex == -1) &&
2196 (_s32AUDIOMutexReboot == -1) &&
2197 (_s32MutexLoadCode == -1) &&
2198 (_s32AUDIOMutexIDMA == -1))
2199 {
2200 return ret;
2201 }
2202
2203 if (_s32AUDIOMutex != -1)
2204 {
2205 if (OS_DELETE_MUTEX(_s32AUDIOMutex) != TRUE)
2206 {
2207 HALAUDIO_ERROR("Error! Delete Mutex failed!\n");
2208 ret = FALSE;
2209 }
2210 _s32AUDIOMutex = -1;
2211 }
2212
2213 if (_s32AUDIOMutexReboot != -1)
2214 {
2215 if (OS_DELETE_MUTEX(_s32AUDIOMutexReboot) != TRUE)
2216 {
2217 HALAUDIO_ERROR("Error! Delete Mutex for Reboot failed!\n");
2218 ret = FALSE;
2219 }
2220 _s32AUDIOMutexReboot = -1;
2221 }
2222
2223 if (_s32MutexLoadCode != -1)
2224 {
2225 if (OS_DELETE_MUTEX(_s32MutexLoadCode) != TRUE)
2226 {
2227 HALAUDIO_ERROR("Error! Delete Mutex for Load DSP failed!\n");
2228 ret = FALSE;
2229 }
2230 _s32MutexLoadCode = -1;
2231 }
2232
2233 if (_s32AUDIOMutexIDMA != -1)
2234 {
2235 if (OS_DELETE_MUTEX(_s32AUDIOMutexIDMA) != TRUE)
2236 {
2237 HALAUDIO_ERROR("Error! Delete Mutex for IMDA failed!\n");
2238 ret = FALSE;
2239 }
2240 _s32AUDIOMutexIDMA = -1;
2241 }
2242
2243 return ret;
2244 }
2245
2246 ////////////////////////////////////////////////////////////////////////////////
2247 /// @brief \b Function \b Name: HAL_AUDIO_GetChipType() @@Cathy
2248 /// @brief \b Function \b Description: This routine is used to get the IC version for API.
2249 /// @param <IN> \b NONE :
2250 /// @param <OUT> \b NONE :
2251 /// @param <RET> \b AU_CHIP_TYPE :
2252 /// @param <GLOBAL> \b NONE :
2253 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetChipType(void)2254 AU_CHIP_TYPE HAL_AUDIO_GetChipType(void)
2255 {
2256 return AU_CHIP_KERES; //Need to refine
2257 }
2258
2259 ////////////////////////////////////////////////////////////////////////////////
2260 /// @brief \b Function \b Name: HAL_AUDIO_Set_MMIO_BASE() @@Cathy
2261 /// @brief \b Function \b Description: This routine is used to set MMIO base
2262 /// @param <IN> \b u32_MMIO_MapBase :
2263 /// @param <OUT> \b NONE :
2264 /// @param <RET> \b :
2265 /// @param <GLOBAL> \b NONE :
2266 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)2267 void HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)
2268 {
2269 _gMIO_MapBase = _MMIO_MapBase; // Get the absolute MMIO address
2270 }
2271
2272 //-------------------------------------------------------------------------------------------------
2273 // Global Functions
2274 //-------------------------------------------------------------------------------------------------
2275
2276 ////////////////////////////////////////////////////////////////////////////////
2277 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadByte @@Cathy
2278 /// @brief \b Function \b Description: read 1 Byte data
2279 /// @param <IN> \b u32RegAddr: register address
2280 /// @param <OUT> \b None :
2281 /// @param <RET> \b MS_U8 : 8-bit register value
2282 /// @param <GLOBAL> \b None :
2283 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)2284 MS_U8 HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)
2285 {
2286 return (_AU_AbsReadByte((u32RegAddr-0x100000)));
2287 }
2288
2289 ////////////////////////////////////////////////////////////////////////////////
2290 /// @brief \b Function \b Name: HAL_AUDIO_ReadByte @@Cathy
2291 /// @brief \b Function \b Description: read 1 Byte data
2292 /// @param <IN> \b u32RegAddr: register address
2293 /// @param <OUT> \b None :
2294 /// @param <RET> \b MS_U8 : 8-bit register value
2295 /// @param <GLOBAL> \b None :
2296 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)2297 MS_U8 HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)
2298 {
2299 return (_AU_AbsReadByte(u32RegAddr+0x010000)); // Add audio bank offset
2300 }
2301
2302
2303 ////////////////////////////////////////////////////////////////////////////////
2304 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadReg @@Cathy
2305 /// @brief \b Function \b Description: read 2 Byte data
2306 /// @param <IN> \b u32RegAddr: register address
2307 /// @param <OUT> \b None :
2308 /// @param <RET> \b MS_U16 : 16-bit register value
2309 /// @param <GLOBAL> \b None :
2310 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)2311 MS_U16 HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)
2312 {
2313 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2314 return _AU_AbsRead2Byte((u32RegAddr-0x100000)); // Add audio bank offset
2315 }
2316
2317 ////////////////////////////////////////////////////////////////////////////////
2318 /// @brief \b Function \b Name: HAL_AUDIO_ReadReg @@Cathy
2319 /// @brief \b Function \b Description: read 2 Byte data
2320 /// @param <IN> \b u32RegAddr: register address
2321 /// @param <OUT> \b None :
2322 /// @param <RET> \b MS_U16 : 16-bit register value
2323 /// @param <GLOBAL> \b None :
2324 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)2325 MS_U16 HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)
2326 {
2327 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2328 return (_AU_AbsRead2Byte(u32RegAddr+0x010000)); // Add audio bank offset
2329 }
2330
2331 ////////////////////////////////////////////////////////////////////////////////
2332 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteReg
2333 /// @brief \b Function \b Description: write 2 Byte data
2334 /// @param <IN> \b u32RegAddr: register address
2335 /// @param <IN> \b u16Val : 2 byte data
2336 /// @param <OUT> \b None :
2337 /// @param <RET> \b None :
2338 /// @param <GLOBAL> \b None :
2339 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2340 void HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2341 {
2342 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2343 _AU_AbsWrite2Byte((u32RegAddr-0x100000),u16Val); // Add audio bank offset
2344 }
2345
2346 ////////////////////////////////////////////////////////////////////////////////
2347 /// @brief \b Function \b Name: HAL_AUDIO_WriteReg @@Cathy
2348 /// @brief \b Function \b Description: write 2 Byte data
2349 /// @param <IN> \b u32RegAddr: register address
2350 /// @param <IN> \b u16Val : 2 byte data
2351 /// @param <OUT> \b None :
2352 /// @param <RET> \b None :
2353 /// @param <GLOBAL> \b None :
2354 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2355 void HAL_AUDIO_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2356 {
2357 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2358 _AU_AbsWrite2Byte((u32RegAddr+0x010000),u16Val); // Add audio bank offset
2359 }
2360
2361 ////////////////////////////////////////////////////////////////////////////////
2362 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteByte
2363 /// @brief \b Function \b Description: write 1 Byte data
2364 /// @param <IN> \b u32RegAddr: register address
2365 /// @param <IN> \b u8Val : 1 byte data
2366 /// @param <OUT> \b None :
2367 /// @param <RET> \b None :
2368 /// @param <GLOBAL> \b None :
2369 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2370 void HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2371 {
2372 _AU_AbsWriteByte((u32RegAddr-0x100000), u8Val); // Add audio bank offset
2373 }
2374
2375 ////////////////////////////////////////////////////////////////////////////////
2376 /// @brief \b Function \b Name: HAL_AUDIO_WriteByte @@Cathy
2377 /// @brief \b Function \b Description: write 1 Byte data
2378 /// @param <IN> \b u32RegAddr: register address
2379 /// @param <IN> \b u8Val : 1 byte data
2380 /// @param <OUT> \b None :
2381 /// @param <RET> \b None :
2382 /// @param <GLOBAL> \b None :
2383 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2384 void HAL_AUDIO_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2385 {
2386 _AU_AbsWriteByte((u32RegAddr+0x010000), u8Val); // Add audio bank offset
2387 }
2388
2389 ////////////////////////////////////////////////////////////////////////////////
2390 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskByte @@Morris
2391 /// @brief \b Function \b Description: Mask write 8-bit data
2392 /// @param <IN> \b u32RegAddr: register address
2393 /// @param <IN> \b u16Val : 8-bit data
2394 /// @param <OUT> \b None :
2395 /// @param <RET> \b None :
2396 /// @param <GLOBAL> \b None :
2397 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2398 void HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2399 {
2400 _AU_AbsWriteMaskByte((u32RegAddr-0x100000), u8Mask, u8Val);
2401 }
2402
2403 ////////////////////////////////////////////////////////////////////////////////
2404 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskByte @@Cathy
2405 /// @brief \b Function \b Description: Mask write 8-bit data
2406 /// @param <IN> \b u32RegAddr: register address
2407 /// @param <IN> \b u16Val : 8-bit data
2408 /// @param <OUT> \b None :
2409 /// @param <RET> \b None :
2410 /// @param <GLOBAL> \b None :
2411 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2412 void HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2413 {
2414 _AU_AbsWriteMaskByte((u32RegAddr+0x010000), u8Mask, u8Val); // Add audio bank offset
2415 }
2416
2417 ////////////////////////////////////////////////////////////////////////////////
2418 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskReg
2419 /// @brief \b Function \b Description: Mask write 16-bit data
2420 /// @param <IN> \b u32RegAddr: register address
2421 /// @param <IN> \b u16Val : 16-bit data
2422 /// @param <OUT> \b None :
2423 /// @param <RET> \b None :
2424 /// @param <GLOBAL> \b None :
2425 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2426 void HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2427 {
2428 MS_U16 u16RegVal;
2429
2430 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2431 u16RegVal = _AU_AbsRead2Byte((u32RegAddr-0x100000));
2432 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2433 _AU_AbsWrite2Byte((u32RegAddr-0x100000), u16RegVal);
2434 }
2435
2436 ////////////////////////////////////////////////////////////////////////////////
2437 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskReg @@Cathy
2438 /// @brief \b Function \b Description: Mask write 16-bit data
2439 /// @param <IN> \b u32RegAddr: register address
2440 /// @param <IN> \b u16Val : 16-bit data
2441 /// @param <OUT> \b None :
2442 /// @param <RET> \b None :
2443 /// @param <GLOBAL> \b None :
2444 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2445 void HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2446 {
2447 MS_U16 u16RegVal;
2448
2449 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2450 u16RegVal = HAL_AUDIO_ReadReg(u32RegAddr);
2451 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2452 HAL_AUDIO_WriteReg(u32RegAddr, u16RegVal);
2453 }
2454
2455 ////////////////////////////////////////////////////////////////////////////////
2456 /// @brief \b Function \b Name: _HAL_AUDIO_Write4Byte @@Cathy
2457 /// @brief \b Function \b Description: write 4 Byte data
2458 /// @param <IN> \b u32RegAddr: register address
2459 /// @param <IN> \b u32Val : 4 byte data
2460 /// @param <OUT> \b None :
2461 /// @param <RET> \b None :
2462 /// @param <GLOBAL> \b None :
2463 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)2464 void _HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
2465 {
2466 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+0x010000] =(MS_U16) (u32Val&0xFFFF);
2467 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+2+0x010000] =(MS_U16) (u32Val>>16);
2468 }
2469
2470 ////////////////////////////////////////////////////////////////////////////////
2471 /// @brief \b Function \b Name: HAL_AUDIO_ReadMailBox() @@Need_Modify
2472 /// @brief \b Function \b Description: This routine is used to read the Dec or SE DSP mail box value
2473 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2474 /// @param <IN> \b u8ParamNum : Mail box address
2475 /// @param <OUT> \b NONE :
2476 /// @param <RET> \b U16 : Mail Box value
2477 /// @param <GLOBAL> \b NONE :
2478 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum)2479 MS_U16 HAL_AUDIO_ReadMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum)
2480 {
2481 MS_U16 u16Tmp1, u16Tmp2;
2482 MS_U32 i, u32MailReg;
2483
2484
2485 for (i=0; i<1000; i++)
2486 {
2487 if(bDspType==DSP_SE)
2488 {
2489 if(u8ParamNum<8)
2490 {
2491 u32MailReg = 0x2D70+(MS_U32)u8ParamNum * 2;
2492 }
2493 else
2494 {
2495 u32MailReg = REG_SE_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2496 }
2497 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2498 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2499 }
2500 else
2501 {
2502 if(u8ParamNum<8)
2503 {
2504 u32MailReg = 0x2D60+(MS_U32)u8ParamNum * 2;
2505 }
2506 else
2507 {
2508 u32MailReg = REG_DEC_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2509 }
2510 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2511 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2512 }
2513 if(u16Tmp1==u16Tmp2)
2514 {
2515 return u16Tmp1;
2516 }
2517 }
2518
2519 printf("Read Mailbox fail! \r\n");
2520 return 0;
2521
2522 }
2523
2524 ////////////////////////////////////////////////////////////////////////////////
2525 /// @brief \b Function \b Name: HAL_AUDIO_WriteDecMailBox() @@Need_Modify
2526 /// @brief \b Function \b Description: This routine is used to write Dec-DSP mail box
2527 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2528 /// @param <IN> \b u8ParamNum : Mail box address
2529 /// @param <IN> \b u16Data : value
2530 /// @param <OUT> \b NONE :
2531 /// @param <RET> \b NONE :
2532 /// @param <GLOBAL> \b NONE :
2533 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum,MS_U16 u16Data)2534 void HAL_AUDIO_WriteMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum, MS_U16 u16Data)
2535 {
2536 MS_U32 u32MailReg;
2537
2538 if(bDspType==DSP_SE)
2539 {
2540 u32MailReg = REG_SE_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2541 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2542 }
2543 else
2544 {
2545 u32MailReg = REG_DEC_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2546 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2547 }
2548 }
2549
2550
2551 ///-----------------------------------------------------------------------------
2552 ////////////////////////////////////////////////////////////////////////////////
2553 ////////////////////////////////////////////////////////////////////////////////
2554 ///
2555 /// AUDIO Initialize Relational Hal Function
2556 ///
2557 ////////////////////////////////////////////////////////////////////////////////
2558
2559 ////////////////////////////////////////////////////////////////////////////////
2560 ///-----------------------------------------------------------------------------
2561 ////////////////////////////////////////////////////////////////////////////////
2562 /// @brief \b Function \b Name: HAL_AUDIO_WriteInitTable() @@Cathy
2563 /// @brief \b Function \b Description: This function is used to write initial register table(8-bit mode)
2564 /// @param <IN> \b NONE :
2565 /// @param <OUT> \b NONE :
2566 /// @param <RET> \b NONE :
2567 /// @param <GLOBAL> \b NONE :
2568 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteInitTable(void)2569 void HAL_AUDIO_WriteInitTable(void)
2570 {
2571 MS_U16 i = 0;
2572
2573 if (HAL_AUDIO_CheckBootOnInitState() == FALSE)
2574 {
2575 while( !((AudioInitTbl_0[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_0[i].u8Mask == 0)) )
2576 {
2577 if((AudioInitTbl_0[i].u32Addr == 0xFFFFFF))
2578 {
2579 if(AudioInitTbl_0[i].u8Mask == 1)
2580 {
2581 if(AudioInitTbl_0[i].u8Value!=0)
2582 MsOS_DelayTask((MS_U32)(AudioInitTbl_0[i].u8Value));
2583 }
2584 }
2585 else
2586 {
2587 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_0[i].u32Addr, AudioInitTbl_0[i].u8Mask, AudioInitTbl_0[i].u8Value);
2588 }
2589
2590 i++;
2591 }
2592 }
2593
2594 i = 0;
2595 while( !((AudioInitTbl_1[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_1[i].u8Mask == 0)) )
2596 {
2597 if((AudioInitTbl_1[i].u32Addr == 0xFFFFFF))
2598 {
2599 if(AudioInitTbl_1[i].u8Mask == 1)
2600 {
2601 if(AudioInitTbl_1[i].u8Value!=0)
2602 MsOS_DelayTask((MS_U32)(AudioInitTbl_1[i].u8Value));
2603 }
2604 }
2605 else
2606 {
2607 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_1[i].u32Addr, AudioInitTbl_1[i].u8Mask, AudioInitTbl_1[i].u8Value);
2608 }
2609 i++;
2610 }
2611
2612 }
2613
2614 ////////////////////////////////////////////////////////////////////////////////
2615 /// @brief \b Function \b Name: HAL_AUDIO_WritePreInitTable()
2616 /// @brief \b Function \b Description: This function is used to set power on DAC sequence before setting init table.
2617 /// @param <IN> \b NONE :
2618 /// @param <OUT> \b NONE :
2619 /// @param <RET> \b NONE :
2620 /// @param <GLOBAL> \b NONE :
2621 ////////////////////////////////////////////////////////////////////////////////
2622 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_WritePreInitTable(void)2623 void HAL_AUDIO_WritePreInitTable(void)
2624 {
2625 MS_U16 i = 0;
2626
2627 if (HAL_AUDIO_CheckBootOnInitState() == TRUE)
2628 {
2629 return;
2630 }
2631
2632 while( !((AudioPreInitTbl_Clock_0[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock_0[i].u8Mask == 0)) )
2633 {
2634 if((AudioPreInitTbl_Clock_0[i].u32Addr == 0xFFFFFF))
2635 {
2636 if(AudioPreInitTbl_Clock_0[i].u8Mask == 1)
2637 {
2638 if(AudioPreInitTbl_Clock_0[i].u8Value!=0)
2639 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock_0[i].u8Value));
2640 }
2641 }
2642 else
2643 {
2644 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock_0[i].u32Addr, AudioPreInitTbl_Clock_0[i].u8Mask, AudioPreInitTbl_Clock_0[i].u8Value);
2645 }
2646 i++;
2647 }
2648
2649 /* DMIO reset */
2650 HAL_AUDIO_DMIOReset();
2651
2652 i = 0;
2653 while( !((AudioPreInitTbl_Clock_1[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock_1[i].u8Mask == 0)) )
2654 {
2655 if((AudioPreInitTbl_Clock_1[i].u32Addr == 0xFFFFFF))
2656 {
2657 if(AudioPreInitTbl_Clock_1[i].u8Mask == 1)
2658 {
2659 if(AudioPreInitTbl_Clock_1[i].u8Value!=0)
2660 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock_1[i].u8Value));
2661 }
2662 }
2663 else
2664 {
2665 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock_1[i].u32Addr, AudioPreInitTbl_Clock_1[i].u8Mask, AudioPreInitTbl_Clock_1[i].u8Value);
2666 }
2667 i++;
2668 }
2669 }
2670
2671 ////////////////////////////////////////////////////////////////////////////////
2672 /// @brief \b Function \b Name: HAL_AUDIO_WriteStopDecTable()
2673 /// @brief \b Function \b Description: This function is used to set stop command to R2/DSP.
2674 /// @param <IN> \b NONE :
2675 /// @param <OUT> \b NONE :
2676 /// @param <RET> \b NONE :
2677 /// @param <GLOBAL> \b NONE :
2678 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteStopDecTable(void)2679 void HAL_AUDIO_WriteStopDecTable(void)
2680 {
2681 MS_U16 i = 0;
2682
2683 while( !((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF) && (Audio_stopDecTbl[i].u8Mask == 0)) )
2684 {
2685 if((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF))
2686 {
2687 if(Audio_stopDecTbl[i].u8Mask == 1)
2688 {
2689 if(Audio_stopDecTbl[i].u8Value!=0)
2690 MsOS_DelayTask((MS_U32)(Audio_stopDecTbl[i].u8Value));
2691 }
2692 }
2693 else
2694 {
2695 HAL_AUDIO_AbsWriteMaskByte(Audio_stopDecTbl[i].u32Addr, Audio_stopDecTbl[i].u8Mask, Audio_stopDecTbl[i].u8Value);
2696 }
2697 i++;
2698 }
2699 }
2700
2701 ////////////////////////////////////////////////////////////////////////////////
2702 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2703 /// @brief \b Function \b Description: This function is used to enable earphone low power stage.
2704 /// @param <IN> \b NONE :
2705 /// @param <OUT> \b NONE :
2706 /// @param <RET> \b NONE :
2707 /// @param <GLOBAL> \b NONE :
2708 ////////////////////////////////////////////////////////////////////////////////
2709 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_LowPower_Stage(void)2710 void HAL_AUDIO_EnaEarphone_LowPower_Stage(void)
2711 {
2712 HAL_AUDIO_AbsWriteMaskByte(0x112B55,0x10,0x00); // disable DWA fix value
2713 return;
2714 }
2715
2716 ////////////////////////////////////////////////////////////////////////////////
2717 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2718 /// @brief \b Function \b Description: This function is used to enable earphone high driving stage.
2719 /// @param <IN> \b NONE :
2720 /// @param <OUT> \b NONE :
2721 /// @param <RET> \b NONE :
2722 /// @param <GLOBAL> \b NONE :
2723 ////////////////////////////////////////////////////////////////////////////////
2724 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)2725 void HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)
2726 {
2727 return;
2728 }
2729
2730 ////////////////////////////////////////////////////////////////////////////////
2731 /// @brief \b Function \b Name: HAL_AUDIO_SetPowerOn() @@Need_Modify
2732 /// @brief \b Function \b Description: This routine is used to execute DSP power on/down setting.
2733 /// @param <IN> \b bPower_on : TRUE --power on
2734 /// FALSE--power off
2735 /// @param <OUT> \b NONE :
2736 /// @param <RET> \b NONE :
2737 /// @param <GLOBAL> \b NONE :
2738 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)2739 void HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)
2740 {
2741 DBG_AUDIO("HAL_AUDIO_SetPowerOn(%x)\r\n", bPower_on);
2742 if(bPower_on)
2743 {
2744 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x00); // DSP power up command, DO NOT touch bit3
2745 HAL_AUDIO_WriteMaskByte(0x2B42, 0xFF, 0x00); // Disable BB by-pass
2746 }
2747 else
2748 {
2749 HAL_AUDIO_DeInitialVars();
2750
2751 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x02); // DSP power down command
2752 AUDIO_DELAY1MS(100);
2753
2754 // Disable MIU Request for DEC-DSP
2755 HAL_MAD_Dis_MIUREQ();
2756 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00); // SPDIF power down
2757 }
2758 }
2759
2760 ////////////////////////////////////////////////////////////////////////////////
2761 /// @brief \b Function \b Name: HAL_AUDIO_ADCInit() @@Cathy
2762 /// @brief \b Function \b Description: This routine is ADC relational register Init.
2763 /// @param <IN> \b NONE :
2764 /// @param <OUT> \b NONE :
2765 /// @param <RET> \b NONE :
2766 /// @param <GLOBAL> \b NONE :
2767 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ADCInit(void)2768 void HAL_AUDIO_ADCInit(void)
2769 {
2770 HAL_AUDIO_WriteMaskByte(0x2CDA, 0x03, 0x00); // power on ADC0 & ADC1
2771 HAL_AUDIO_WriteMaskByte(0x2CEE, 0x03, 0x03); //enable ADC dither
2772 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00); // power on ADC PGA
2773 HAL_AUDIO_WriteMaskByte(0x2CE5, 0xFC, 0x00); //ADC0 & ADC1 PGAain=0dB
2774 }
2775
2776 ////////////////////////////////////////////////////////////////////////////////
2777 /// @brief \b Function \b Name: HAL_AUDIO_SwResetMAD() @@Cathy
2778 /// @brief \b Function \b Description: This function is used to software reset MAD
2779 /// @param <IN> \b NONE :
2780 /// @param <OUT> \b NONE :
2781 /// @param <RET> \b NONE :
2782 /// @param <GLOBAL> \b NONE :
2783 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SwResetMAD(void)2784 void HAL_AUDIO_SwResetMAD(void)
2785 {
2786 /* DMIO reset */
2787 HAL_AUDIO_DMIOReset();
2788
2789 /* Audio software engine reset */
2790 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
2791 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2792 AUDIO_DELAY1MS(1);
2793 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0F);
2794 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2795 AUDIO_DELAY1MS(1);
2796 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
2797 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2798 AUDIO_DELAY1MS(1);
2799 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x00);
2800 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x00);
2801 AUDIO_DELAY1MS(1);
2802 }
2803
2804 ////////////////////////////////////////////////////////////////////////////////
2805 /// @brief \b Function \b Name: HAL_AUDIO_ResetDSP() @@Cathy
2806 /// @brief \b Function \b Description: This function is used to reset DSP.
2807 /// @param <IN> \b NONE :
2808 /// @param <OUT> \b NONE :
2809 /// @param <RET> \b NONE :
2810 /// @param <GLOBAL> \b NONE :
2811 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ResetDSP(void)2812 void HAL_AUDIO_ResetDSP(void)
2813 {
2814 HAL_AUDIO_DecWriteByte(REG_SE_IDMA_CTRL0, 0x82); // Reset DSP
2815 AUDIO_DELAY1MS(2);
2816 HAL_AUDIO_DecWriteByte(REG_SE_IDMA_CTRL0, 0x83);
2817 }
2818
2819 ////////////////////////////////////////////////////////////////////////////////
2820 /// @brief \b Function \b Name: HAL_AUDIO_DecDspISR() @@Need_Modify
2821 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2822 /// @param <IN> \b NONE :
2823 /// @param <OUT> \b NONE :
2824 /// @param <RET> \b NONE :
2825 /// @param <GLOBAL> \b NONE :
2826 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecDspISR(void)2827 void HAL_AUDIO_DecDspISR(void) //Cathy need modify
2828 {
2829 MS_U8 dec_ISR_cmdType;
2830
2831 dec_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_DEC_ISRCMD);
2832
2833 HALAUDIO_CHECK_SHM_INIT;
2834
2835 if(dec_ISR_cmdType == 0x3)
2836 {
2837 g_AudioVars2->g_bDecPlayFileFlag = TRUE;
2838 }
2839 else if(dec_ISR_cmdType == 0x13) // MPEG encode ISR
2840 {
2841 HAL_AUDIO_SetEncodeDoneFlag(1); // for PVR encode done, kochien modified
2842 EncBuf_Count++; // remaining data in buffer
2843 EncFrameIdx += 16; //default 16 frames / interrupt
2844 MPEG_EN_BUF[EncBuf_W_idx].u32Addr = ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINEADDR))*16;
2845 MPEG_EN_BUF[EncBuf_W_idx].u32Size= ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINESIZE))*16;
2846 MPEG_EN_BUF[EncBuf_W_idx].u64Idx= (MS_U64)EncFrameIdx; //(MS_U64)(((EncFrameIdx-1)*1152*90)/48);
2847
2848 if(EncBuf_W_idx == 5)// (ENC_BUF_SIZE-1)) // circular buffer // manually circular...
2849 EncBuf_W_idx = 0;
2850 else
2851 EncBuf_W_idx++;
2852 }
2853 else if (dec_ISR_cmdType == 0x07) // 2nd Decoder ISR in MM
2854 {
2855 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2856 }
2857 }
2858
2859 ////////////////////////////////////////////////////////////////////////////////
2860 /// @brief \b Function \b Name: HAL_AUDIO_SeDspISR() @@Need_Modify
2861 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2862 /// @param <IN> \b NONE :
2863 /// @param <OUT> \b NONE :
2864 /// @param <RET> \b NONE :
2865 /// @param <GLOBAL> \b NONE :
2866 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeDspISR(void)2867 void HAL_AUDIO_SeDspISR(void)
2868 {
2869 MS_U8 se_ISR_cmdType;
2870
2871 se_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_SE_ISRCMD);
2872
2873 /* add for PIP ASND Decode */
2874 if ( se_ISR_cmdType == 0x03 )
2875 {
2876 if (g_AudioVars2 != NULL)
2877 {
2878 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2879 }
2880 }
2881 }
2882
2883 ////////////////////////////////////////////////////////////////////////////////
2884 /// @brief \b Function \b Name: HAL_AUDIO_SetPlayFileFlag() @Cathy
2885 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2886 /// @param <IN> \b NONE :
2887 /// @param <OUT> \b NONE :
2888 /// @param <RET> \b NONE :
2889 /// @param <GLOBAL> \b NONE :
2890 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType,MS_BOOL bSet)2891 void HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType, MS_BOOL bSet)
2892 {
2893 HALAUDIO_CHECK_SHM_INIT;
2894
2895 if(bDspType == DSP_DEC)
2896 {
2897 g_AudioVars2->g_bDecPlayFileFlag = bSet;
2898 }
2899 else
2900 {
2901 g_AudioVars2->g_bSePlayFileFlag = bSet;
2902 }
2903 }
2904
2905 ////////////////////////////////////////////////////////////////////////////////
2906 /// @brief \b Function \b Name: HAL_AUDIO_GetPlayFileFlag() @@Cathy
2907 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2908 /// @param <IN> \b NONE :
2909 /// @param <OUT> \b NONE :
2910 /// @param <RET> \b NONE :
2911 /// @param <GLOBAL> \b NONE :
2912 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)2913 MS_BOOL HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)
2914 {
2915 MS_U32 es_rdPtr, es_wrPtr;
2916 MS_S32 es_level, es_bufSz, es_freeSpace;
2917 MS_U32 es_reqSize;
2918 MS_U8 r2_dec_id;
2919
2920 if(bDspType ==DSP_DEC)
2921 r2_dec_id = ADEC1;
2922 else if(bDspType ==DSP_SE)
2923 r2_dec_id = ADEC2;
2924 else
2925 r2_dec_id = ADEC1; //default case
2926
2927 es_rdPtr = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, r2_dec_id );
2928 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM( R2_SHM_PARAM_ES_WR_PTR, r2_dec_id, 0 );
2929 es_reqSize = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, r2_dec_id);
2930
2931 if (r2_dec_id == ADEC1)
2932 es_bufSz = ES1_DRAM_SIZE;
2933 else
2934 es_bufSz = ES3_DRAM_SIZE;
2935
2936 es_level = es_wrPtr - es_rdPtr;
2937
2938 if (es_level < 0)
2939 es_level += es_bufSz;
2940
2941 es_freeSpace = es_bufSz - es_level;
2942
2943 if ( es_freeSpace > es_reqSize )
2944 return TRUE;
2945 else
2946 return FALSE;
2947 }
2948
2949 ////////////////////////////////////////////////////////////////////////////////
2950 /// @brief \b Function \b Name: HAL_AUDIO_SetEncodeDoneFlag() @@Cathy
2951 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2952 /// @param <IN> \b NONE :
2953 /// @param <OUT> \b NONE :
2954 /// @param <RET> \b NONE :
2955 /// @param <GLOBAL> \b NONE :
2956 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)2957 void HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)
2958 {
2959 if(bSet)
2960 g_bEncodeDoneFlag= 1;
2961 else
2962 g_bEncodeDoneFlag = 0;
2963 }
2964
2965 ////////////////////////////////////////////////////////////////////////////////
2966 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeDoneFlag() @@Cathy
2967 /// @brief \b Function \b Description: This function is used to get the Encoder flag status
2968 /// @param <IN> \b NONE :
2969 /// @param <OUT> \b NONE :
2970 /// @param <RET> \b NONE :
2971 /// @param <GLOBAL> \b NONE :
2972 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeDoneFlag(void)2973 MS_BOOL HAL_AUDIO_GetEncodeDoneFlag(void)
2974 {
2975 return g_bEncodeDoneFlag;
2976 }
2977
2978 ////////////////////////////////////////////////////////////////////////////////
2979 /// @brief \b Function \b Name: HAL_AUDIO_CheckBootOnInitState()
2980 /// @brief \b Function \b Description: This routine is used to check whether mboot load init script
2981 /// @param void
2982 /// @return MS_U16 \b : Mail Box value
2983 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckBootOnInitState(void)2984 MS_BOOL HAL_AUDIO_CheckBootOnInitState(void)
2985 {
2986 if ((HAL_AUDIO_ReadByte(REG_AUDIO_AUDIO_INIT_CHECK) & 0x1) == 0)
2987 {
2988 return FALSE;
2989 }
2990 else
2991 {
2992 return TRUE;
2993 }
2994 }
2995
2996 /////////////////////////////////////////////////////////////////////////////////
2997 /// ///
2998 /// AUDIO I/O Config Relational Hal Function ///
2999 /// ///
3000 ////////////////////////////////////////////////////////////////////////////////
3001
3002 ////////////////////////////////////////////////////////////////////////////////
3003 /// @brief \b Function \b Name: HAL_AUDIO_GetPathGroup()
3004 /// @brief \b Function \b Description: This routine is used to get Audio path group type .
3005 /// @param output \b : Audio output path-group type
3006 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPathGroup(void)3007 AUDIO_PATH_GROUP_TYPE HAL_AUDIO_GetPathGroup(void)
3008 {
3009 // AUDIO_PATH_GROUP_1 : U3, Janus
3010 // AUDIO_PATH_GROUP_2 : T3, U4, T8, T9, T12, T13, J2
3011 return(AUDIO_PATH_GROUP_2);
3012 }
3013
3014 ////////////////////////////////////////////////////////////////////////////////
3015 /// @brief \b Function \b Name: HAL_AUDIO_SetNormalPath() @@ No used in T3 @@VVV
3016 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input and Output.
3017 /// @param <IN> \b u8Path : Audio DSP channel
3018 /// @param <IN> \b input : Audio input type
3019 /// @param <IN> \b output : Audio output type
3020 /// @param <OUT> \b NONE :
3021 /// @param <RET> \b NONE :
3022 /// @param <GLOBAL> \b NONE :
3023 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path,AUDIO_INPUT_TYPE input,AUDIO_OUTPUT_TYPE output)3024 void HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path, AUDIO_INPUT_TYPE input, AUDIO_OUTPUT_TYPE output)
3025 {
3026 UNUSED(u8Path);
3027 UNUSED(input);
3028 UNUSED(output);
3029 }
3030
3031 ////////////////////////////////////////////////////////////////////////////////
3032 /// @brief \b Function \b Name: HAL_AUDIO_SetInputPath() @@VVV
3033 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input .
3034 /// @param <IN> \b input : Audio input type
3035 /// @param <IN> \b u8Path : Audio DSP channel
3036 /// @param <OUT> \b NONE :
3037 /// @param <RET> \b NONE :
3038 /// @param <GLOBAL> \b NONE :
3039 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input,AUDIO_PATH_TYPE u8Path)3040 void HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input , AUDIO_PATH_TYPE u8Path)
3041 {
3042 MS_U32 u32path_reg;
3043 MS_U8 u8input_src, u8input_idx, u8temp, path;
3044 AUDIO_INPUT_TYPE input1; // define this in order to do more check for ATV input source.
3045 input1 = input;
3046
3047 HALAUDIO_CHECK_SHM_INIT;
3048
3049 if((input == AUDIO_NULL_INPUT) || (u8Path ==AUDIO_PATH_NULL))
3050 {
3051 return;
3052 }
3053
3054 u8input_src = LONIBBLE(input);
3055 u8input_idx = HINIBBLE(input);
3056
3057 if( u8Path == AUDIO_PATH_MAIN )
3058 {
3059 if (u8input_src == AUDIO_ADC_INPUT || u8input_src == AUDIO_ADC2_INPUT)
3060 {
3061 HAL_SOUND_EnableDcRemove(TRUE);
3062 }
3063 else
3064 {
3065 HAL_SOUND_EnableDcRemove(FALSE);
3066 }
3067 }
3068
3069 path=(MS_U8)u8Path;
3070
3071 /* save main speaker audio input */
3072 if( u8Path == AUDIO_PATH_MAIN )
3073 {
3074 g_AudioVars2->eMainAudioSource = input1;
3075 }
3076 /* save sub channel audio input */
3077 else if( u8Path == AUDIO_PATH_6 )
3078 {
3079 g_AudioVars2->eSubAudioSource = input1;
3080 }
3081
3082 if( path >= (sizeof(u32PathArray)/sizeof(u32PathArray[0])))
3083 {
3084 DBG_AUDIO(printf("DSP is not support more than CH8\n"));
3085 return;
3086 }
3087
3088 u32path_reg = u32PathArray[path];
3089
3090 // Set input
3091 switch(u8input_src)
3092 {
3093 case AUDIO_DSP1_INPUT:
3094 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x80);
3095 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG, 0x07,u8input_idx);
3096 break;
3097
3098 case AUDIO_DSP2_INPUT:
3099 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x81);
3100 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx);
3101 break;
3102
3103 case AUDIO_DSP3_INPUT:
3104 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x82);
3105 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x07,u8input_idx);
3106 break;
3107
3108 case AUDIO_DSP4_INPUT:
3109 /*
3110 * A patch here!
3111 * Just a temporary solution to hardcode channel 7 to 0x90 for HW DMA Reader2,
3112 */
3113 if (u8input_idx == 0x7)
3114 {
3115 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x83);
3116 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER4_CFG, 0x07, u8input_idx);
3117 }
3118 else
3119 {
3120 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x90);
3121 }
3122 break;
3123
3124 case AUDIO_ADC_INPUT:
3125 if(u8input_idx==0x0A)
3126 u8temp=0x40;
3127 else if(u8input_idx==0x0B)
3128 u8temp=0x50;
3129 else
3130 u8temp = (u8input_idx<<4);
3131 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x08);
3132 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, u8temp );
3133 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00 ); //disable power down INMUX
3134 break;
3135
3136 case AUDIO_ADC2_INPUT:
3137 if(u8input_idx==0x0A)
3138 u8temp=0x04;
3139 else if(u8input_idx==0x0B)
3140 u8temp=0x05;
3141 else
3142 u8temp = u8input_idx;
3143 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x09);
3144 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp );
3145 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00 ); //disable power down INMUX
3146 break;
3147
3148 case AUDIO_SPDIF_INPUT:
3149 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x86);
3150 break;
3151
3152 case AUDIO_I2S_INPUT:
3153 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x85);
3154 break;
3155
3156 case AUDIO_HDMI_INPUT:
3157 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x84);
3158 break;
3159
3160 case AUDIO_DMA_INPUT:
3161 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x0F);
3162 break;
3163
3164 default:
3165 break;
3166 }
3167
3168 }
3169
3170 ////////////////////////////////////////////////////////////////////////////////
3171 /// @brief \b Function \b Name: HAL_AUDIO_SetOutputPath() @@Need_Modify
3172 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
3173 /// @param <IN> \b u8Path : Audio DSP channel
3174 /// @param <IN> \b output : Audio output type
3175 /// @param <OUT> \b NONE :
3176 /// @param <RET> \b NONE :
3177 /// @param <GLOBAL> \b NONE :
3178 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)3179 void HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
3180 {
3181 UNUSED(u8Path);
3182 UNUSED(u8Output);
3183 }
3184
3185 ////////////////////////////////////////////////////////////////////////////////
3186 /// @brief \b Function \b Name: HAL_AUDIO_SetInternalPath() @@VVV
3187 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
3188 /// @param <IN> \b u8Path : Audio internal path
3189 /// @param <IN> \b output : Audio output type
3190 /// @param <OUT> \b NONE :
3191 /// @param <RET> \b NONE :
3192 /// @param <GLOBAL> \b NONE :
3193 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)3194 void HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
3195 {
3196 MS_U8 path;
3197 // OUT0, OUT1, OUT2 , OUT3 , S/PDIF, I2S, HP , Dummy, Dummy, HDMI
3198 MS_U8 BalanceBitMap[10]={ 0, 1, 2, 3, 5, 4, 1, 7, 7, 10 };
3199
3200 if(u8Path >= INTERNAL_MAX_NUM)
3201 return;
3202
3203 path = (MS_U8)u8Path;
3204
3205 if(u8Path==INTERNAL_PCM_SE) // Only speaker use this path
3206 {
3207 g_BalanceMask=g_BalanceMask|(0x01<<BalanceBitMap[(int)u8Output]); // Enable balance mask
3208 }
3209
3210 if((HAL_AUDIO_ReadByte(M2S_MBOX_BALANCE_EN+1)&0x80)!=0)
3211 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
3212 else
3213 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000); // Balance disable
3214
3215 // Set output
3216 switch(u8Output)
3217 {
3218 case AUDIO_AUOUT0_OUTPUT:
3219 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0x0F, path);
3220 break;
3221
3222 case AUDIO_AUOUT1_OUTPUT:
3223 case AUDIO_HP_OUTPUT:
3224 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0xF0, (path<<4));
3225 break;
3226
3227 case AUDIO_AUOUT2_OUTPUT:
3228 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0x0F, path);
3229 break;
3230
3231 case AUDIO_AUOUT3_OUTPUT:
3232 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0xF0, (path<<4));
3233 break;
3234
3235 case AUDIO_I2S_OUTPUT:
3236 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0x0F, path);
3237 break;
3238
3239 case AUDIO_SPDIF_OUTPUT:
3240 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3+1, 0x0F, path); // Fix PCM in
3241 break;
3242
3243 case AUDIO_HDMI_OUTPUT:
3244 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3, 0x0F, path);
3245 break;
3246
3247 default:
3248 break;
3249 }
3250 }
3251
3252
3253 ////////////////////////////////////////////////////////////////////////////////
3254 /// @brief \b Function \b Name: HAL_AUDIO_FwTriggerDSP() @@Need_Modify
3255 /// @brief \b Function \b Description: This routine send a PIO11 interrupt to DSP with a command on 0x2D34.
3256 /// @param <IN> \b cmd : 0xF0-- for MHEG5 file protocol
3257 /// @param <OUT> \b NONE :
3258 /// @param <RET> \b NONE :
3259 /// @param <GLOBAL> \b NONE :
3260 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd)3261 void HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd) //Cathy need modify
3262 {
3263 UNUSED(u16Cmd);
3264 }
3265
3266 ////////////////////////////////////////////////////////////////////////////////
3267 /// @brief \b Function \b Name: HAL_AUDIO_DspBootOnDDR()
3268 /// @brief \b Function \b Description: Enable DSP load / reload code from DDR
3269 /// @param <IN> \b bEnable : 0 -- load code from FLASH
3270 /// 1 -- load code from DDR
3271 /// @param <OUT> \b NONE :
3272 /// @param <RET> \b NONE :
3273 /// @param <GLOBAL> \b NONE :
3274 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)3275 void HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)
3276 {
3277 g_bAudio_loadcode_from_dram = bEnable;
3278 }
3279
3280 ////////////////////////////////////////////////////////////////////////////////
3281 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3282 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3283 /// @param <IN> \b NONE :
3284 /// @param <OUT> \b NONE :
3285 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3286 /// @param <GLOBAL> \b NONE :
3287 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetIsDtvFlag(void)3288 MS_BOOL HAL_AUDIO_GetIsDtvFlag(void)
3289 {
3290 return g_bIsDTV;
3291 }
3292
3293 ////////////////////////////////////////////////////////////////////////////////
3294 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3295 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3296 /// @param <IN> \b NONE :
3297 /// @param <OUT> \b NONE :
3298 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3299 /// @param <GLOBAL> \b NONE :
3300 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)3301 void HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)
3302 {
3303 g_bIsDTV=bIsDTV;
3304 }
3305
3306 ////////////////////////////////////////////////////////////////////////////////
3307 /// @brief \b Function \b Name: HAL_AUDIO_Dec_Status() @@Cathy
3308 /// @brief \b Function \b Description: This routine is used to read the Decoder status.
3309 /// @param <IN> \b NONE :
3310 /// @param <OUT> \b NONE :
3311 /// @param <RET> \b MS_U8 : Decoder Status
3312 /// @param <GLOBAL> \b NONE :
3313 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Dec_Status(void)3314 MS_U8 HAL_AUDIO_Dec_Status(void)
3315 {
3316 return(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD));
3317 }
3318
3319 ////////////////////////////////////////////////////////////////////////////////
3320 /// @brief \b Function \b Name: HAL_AUDIO_Enc_Status() @@Kochien.Kuo
3321 /// @brief \b Function \b Description: This routine is used to read the Encoder status.
3322 /// @param <IN> \b NONE :
3323 /// @param <OUT> \b NONE :
3324 /// @param <RET> \b MS_U8 : Encoder Status
3325 /// @param <GLOBAL> \b NONE :
3326 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Enc_Status(void)3327 MS_U8 HAL_AUDIO_Enc_Status(void)
3328 {
3329 return(HAL_AUDIO_ReadByte(REG_DEC_ENCODE_CMD));
3330 }
3331
3332 ////////////////////////////////////////////////////////////////////////////////
3333 /// @brief \b Function \b Name: HAL_AUDIO_SE_Status() @@Cathy
3334 /// @brief \b Function \b Description: This routine is used to read the SE status.
3335 /// @param <IN> \b NONE :
3336 /// @param <OUT> \b NONE :
3337 /// @param <RET> \b MS_U8 : Decoder Status
3338 /// @param <GLOBAL> \b NONE :
3339 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Se_Status(void)3340 MS_U8 HAL_AUDIO_Se_Status(void)
3341 {
3342 return(HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD));
3343 }
3344
3345 ////////////////////////////////////////////////////////////////////////////////
3346 /// @brief \b Function \b Name: HAL_AUDIO_Set_Fading() @@Need_Modify
3347 /// @brief \b Function \b Description: This routine is used to set the Fading response time
3348 /// @param <IN> \b u32VolFading : Fading response time parameter
3349 /// @param <OUT> \b NONE :
3350 /// @param <RET> \b NONE :
3351 /// @param <GLOBAL> \b NONE :
3352 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)3353 void HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)
3354 {
3355 UNUSED(u32VolFading);
3356 }
3357
3358
3359 ////////////////////////////////////////////////////////////////////////////////
3360 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetUploadRate() @@Need_Modify
3361 /// @brief \b Function \b Description: According Blue tooth upload path, for different sampling rate setting the Synthesizer.
3362 /// @param <IN> \b bEnable : 0 -- Disable Blue Tooth upload
3363 /// 1 -- Enable Blue Tooth upload
3364 /// @param <IN> \b u8Samprate: Sampling Rate
3365 /// 0--no change
3366 /// 1--48KHz
3367 /// 2--44KHz
3368 /// 3--32KHz
3369 /// @param <OUT> \b NONE :
3370 /// @param <RET> \b NONE :
3371 /// @param <GLOBAL> \b NONE :
3372 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)3373 void HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)
3374 {
3375 u8Samprate &= 0x0003;
3376
3377 if(bEnable)
3378 {
3379 HAL_AUDIO_DecWriteByte(0x2C5A, 0x55);
3380 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0x10);
3381 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,u8Samprate);
3382 }
3383 else
3384 {
3385 HAL_AUDIO_DecWriteByte(0x2C5A, 0);
3386 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0);
3387 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,0);
3388 }
3389 }
3390
3391
3392 ////////////////////////////////////////////////////////////////////////////////
3393 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetBufferCounter() @@Need_Modify
3394 /// @brief \b Function \b Description: Set the DDR buffer according the sampling rate and the frame time
3395 /// @param <IN> \b u32Counter : if the sampling rate is 48KHz, the frame time is 40ms
3396 /// ==> the frame buffer size is 48000*0x04*2 (L/R) *2(Bytes/sample) = 0x1E00
3397 /// the counter is 0x1E00/8 = 960 (For 1*Burst DMA)
3398 /// @param <OUT> \b NONE :
3399 /// @param <RET> \b NONE :
3400 /// @param <GLOBAL> \b NONE :
3401 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)3402 void HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)
3403 {
3404 u32Counter &= 0x00FFFFFF;
3405 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_btFrameSize, u32Counter);
3406 }
3407
3408 ////////////////////////////////////////////////////////////////////////////////
3409 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_Enable() @@Need_Modify
3410 /// @brief \b Function \b Description: Enable/ Disable the path of USB PCM
3411 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
3412 /// @param <OUT> \b NONE :
3413 /// @param <RET> \b NONE :
3414 /// @param <GLOBAL> \b NONE :
3415 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)3416 void HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)
3417 {
3418 //this funcion is removed from DSP
3419 UNUSED(bEnable);
3420 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3421 }
3422
3423
3424 ////////////////////////////////////////////////////////////////////////////////
3425 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetFlag() @@Need_Modify
3426 /// @brief \b Function \b Description: Get interrupt flag for USBPCM function
3427 /// \b (Encoder path)
3428 /// @param <IN> \b NONE :
3429 /// @param <OUT> \b NONE :
3430 /// @param <RET> \b BOOL : interrupt flag
3431 /// @param <GLOBAL> \b NONE :
3432 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetFlag()3433 MS_BOOL HAL_AUDIO_USBPCM_GetFlag()
3434 {
3435 //this funcion is removed from DSP
3436 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3437 return 0;
3438 }
3439
3440 ////////////////////////////////////////////////////////////////////////////////
3441 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_SetFlag() @@Need_Modify
3442 /// @brief \b Function \b Description: clear interrupt flag for USBPCM function
3443 /// \b (Encoder path)
3444 /// @param <IN> \b bEnable : set false to clean interrupt flag
3445 /// @param <OUT> \b NONE :
3446 /// @param <RET> \b NONE :
3447 /// @param <GLOBAL> \b NONE :
3448 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)3449 void HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)
3450 {
3451 //this funcion is removed from DSP
3452 UNUSED(bEnable);
3453 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3454 }
3455
3456 ////////////////////////////////////////////////////////////////////////////////
3457 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetMemInfo() @@Need_Modify
3458 /// @brief \b Function \b Description: Get memory address and size for USBPCM function
3459 /// \b (Encoder path)
3460 /// @param <IN> \b NONE :
3461 /// @param <OUT> \b MS_U32 : address, size
3462 /// @param <RET> \b NONE :
3463 /// @param <GLOBAL> \b NONE :
3464 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO * uploadInfo)3465 void HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO *uploadInfo)
3466 {
3467 //this funcion is removed from DSP
3468 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3469 }
3470
3471 ////////////////////////////////////////////////////////////////////////////////
3472 /// @brief \b Function \b Name: HAL_AUDIO_ I2S_SetMode() @@Need_Modify
3473 /// @brief \b Function \b Description: This routine is used to Set the I2S output mode.
3474 /// @param <IN> \b Mode : MCLK , WORD_WIDTH , SOURCE_CH , FORMAT
3475 /// @param <IN> \b Value : Please reference the register table 0x2C8C & 0x2C8D .
3476 /// @param <OUT> \b NONE :
3477 /// @param <RET> \b NONE :
3478 /// @param <GLOBAL> \b NONE :
3479 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode,MS_U8 u8Val)3480 void _HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode, MS_U8 u8Val)
3481 {
3482
3483 MS_U8 u8Width_Reg;
3484
3485 switch(u8Mode)
3486 {
3487 case AUDIO_I2S_MCLK: //0x2C8C[6:4]
3488 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x70,u8Val<<4);
3489 break;
3490
3491 case AUDIO_I2S_WORD_WIDTH: //0x2C8C[2:0]
3492 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x07,u8Val);
3493 break;
3494
3495 case AUDIO_I2S_FORMAT: //0x2C8C[3]
3496 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x08,u8Val<<3);
3497 break;
3498
3499 case AUDIO_I2S_SOURCE_CH:
3500 // No need ; Only select Group A in T3 .
3501 break;
3502
3503 case AUDIO_I2S_RXMODE:
3504 if(u8Val==I2S_SLAVE_MODE) //slave mode
3505 { //0x2C8C[2], 2CAE[13], 2CCE[15:13][1:0]
3506 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_TRX_TIMING_GEN, 0x10, 0x00);
3507 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x00);
3508 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0x00);
3509 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0x20);
3510 }
3511 else //master mode
3512 {
3513 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_TRX_TIMING_GEN, 0x10, 0x10);
3514 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x04);
3515 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0xA0);
3516 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0xC0);
3517 }
3518 break;
3519
3520 case AUDIO_I2S_RX_JUSTIFIED_MODE:
3521 if(u8Val==I2S_FORMAT_STANDARD) //I2S_FORMAT_STANDARD
3522 {
3523 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x08,0x00);
3524 }
3525 else //I2S_FORMAT_LEFT_JUSTIFIED
3526 {
3527 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x08,0x08);
3528 }
3529
3530 break;
3531 //Div = 7680 / (Width*4 / (48K / Sample Rate) ) Ex: 16 bit Div = 7680/(16*4/3) = 360 = 0x168
3532 case AUDIO_I2S_RX_CLOCK:
3533
3534 u8Width_Reg = HAL_AUDIO_ReadByte(REG_AUDIO_ASIF_TST + 1);
3535
3536 if((u8Width_Reg & 0x18) == 0x00)
3537 {
3538 if(u8Val == I2S_SAMPLE_RATE_16K)
3539 {
3540 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x01);
3541 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x68);
3542 }
3543 else if(u8Val == I2S_SAMPLE_RATE_32K)
3544 {
3545 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3546 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0xB4);
3547 }
3548 else if(u8Val == I2S_SAMPLE_RATE_48K)
3549 {
3550 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3551 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x78);
3552 }
3553 }
3554 else if((u8Width_Reg & 0x18) == 0x08)
3555 {
3556 if(u8Val == I2S_SAMPLE_RATE_16K)
3557 {
3558 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3559 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0xF0);
3560 }
3561 else if(u8Val == I2S_SAMPLE_RATE_32K)
3562 {
3563 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3564 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x78);
3565 }
3566 else if(u8Val == I2S_SAMPLE_RATE_48K)
3567 {
3568 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3569 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x4F);
3570 }
3571
3572 }
3573 else if((u8Width_Reg & 0x18) == 0x10)
3574 {
3575 if(u8Val == I2S_SAMPLE_RATE_16K)
3576 {
3577 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3578 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0xB4);
3579 }
3580 else if(u8Val == I2S_SAMPLE_RATE_32K)
3581 {
3582 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3583 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x5A);
3584 }
3585 else if(u8Val == I2S_SAMPLE_RATE_48K)
3586 {
3587 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x01,0x00);
3588 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST,0xFF,0x3B);
3589 }
3590
3591 }
3592
3593 break;
3594
3595 case AUDIO_I2S_RX_WORD_WIDTH:
3596 if(u8Val == I2S_WORD_WIDTH_16BIT)
3597 {
3598 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x18,0x00);
3599 }
3600 else if(u8Val == I2S_WORD_WIDTH_24BIT)
3601 {
3602 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x18,0x08);
3603
3604 }
3605 else if(u8Val == I2S_WORD_WIDTH_32BIT)
3606 {
3607 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST + 1,0x18,0x10);
3608 }
3609
3610 case AUDIO_I2S_TXMODE:
3611 // Tx always Master Mode;
3612 break;
3613
3614 default:
3615 break;
3616 };
3617 }
3618
HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType,MS_BOOL bEnable)3619 static void HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType, MS_BOOL bEnable)
3620 {
3621 switch(eType)
3622 {
3623 case DD_DDCO:
3624 if(bEnable == TRUE)
3625 {
3626 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x1 );
3627 }
3628 else
3629 {
3630 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x0 );
3631 }
3632 break;
3633
3634 case DD_DDENCODE:
3635 if(bEnable == TRUE)
3636 {
3637 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x2 );
3638 }
3639 else
3640 {
3641 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x0 );
3642 }
3643 break;
3644
3645 case DTS_ENCODE_2CH:
3646 case DTS_ENCODE_MULTI:
3647 case MP3_ENCODE:
3648 default:
3649 HALAUDIO_ERROR("%s() - Choosen Encoder not exist\n",__FUNCTION__);
3650 break;
3651 }
3652 }
3653
HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DSP_ID eDspID)3654 static void HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DSP_ID eDspID)
3655 {
3656 switch (ePath)
3657 {
3658 case DIGITAL_SPDIF_OUTPUT:
3659 {
3660 switch(eDspID)
3661 {
3662 case AUDIO_DSP_ID_R2:
3663 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x4);
3664 break;
3665 case AUDIO_DSP_ID_SND:
3666 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x8);
3667 break;
3668 case AUDIO_DSP_ID_DEC:
3669 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x0);
3670 break;
3671 default:
3672 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3673 break;
3674 }
3675 }
3676 break;
3677
3678 case DIGITAL_HDMI_ARC_OUTPUT:
3679 {
3680 switch(eDspID)
3681 {
3682 case AUDIO_DSP_ID_R2:
3683 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3684 break;
3685 case AUDIO_DSP_ID_SND:
3686 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3687 break;
3688 case AUDIO_DSP_ID_DEC:
3689 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3690 break;
3691 default:
3692 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3693 break;
3694 }
3695 }
3696 break;
3697
3698 case DIGITAL_HDMI_OUTPUT:
3699 {
3700 switch(eDspID)
3701 {
3702 case AUDIO_DSP_ID_R2:
3703 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3704 break;
3705 case AUDIO_DSP_ID_SND:
3706 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3707 break;
3708 case AUDIO_DSP_ID_DEC:
3709 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3710 break;
3711 default:
3712 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3713 break;
3714 }
3715 }
3716 break;
3717
3718 default:
3719 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3720 break;
3721 }
3722
3723 }
3724
HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath,MS_BOOL bEnable)3725 static void HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath, MS_BOOL bEnable)
3726 {
3727
3728 switch(ePath)
3729 {
3730 case DIGITAL_SPDIF_OUTPUT:
3731 if(bEnable == TRUE)
3732 {
3733 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
3734 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
3735 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x2);
3736 }
3737 else
3738 {
3739 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select DSP1 */
3740 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
3741 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
3742 }
3743 break;
3744
3745 case DIGITAL_HDMI_ARC_OUTPUT:
3746 if(bEnable == TRUE)
3747 {
3748 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3749 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3750 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3751 }
3752 else
3753 {
3754 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3755 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3756 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3757 }
3758 break;
3759
3760 case DIGITAL_HDMI_OUTPUT:
3761 if(bEnable == TRUE)
3762 {
3763 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3764 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3765 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3766 }
3767 else
3768 {
3769 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3770 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3771 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3772 }
3773 break;
3774
3775 default:
3776 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3777 break;
3778 }
3779 }
3780 ////////////////////////////////////////////////////////////////////////////////
3781 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3782 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3783 /// @param <IN> \b u8Spdif_mode :
3784 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3785 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3786 /// bit[2] = 1: non-PCM NULL Payload
3787 /// @param <IN> \b u8Input_src 0 : DTV
3788 /// 1 : ATV
3789 /// 2 : HDMI
3790 /// 3 : ADC
3791 /// 4 : CardReader
3792 /// 5 : SPDIF
3793 /// @param <OUT> \b NONE :
3794 /// @param <RET> \b NONE :
3795 /// @param <GLOBAL> \b NONE :
3796 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSetting)3797 static void HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSetting)
3798 {
3799 MS_BOOL ret = FALSE;
3800 Digital_Out_Channel_Status_t stDigitalChannelStatus;
3801 memset(&stDigitalChannelStatus, 0x00, sizeof(Digital_Out_Channel_Status_t));
3802
3803 if (ePath == DIGITAL_SPDIF_OUTPUT)
3804 {
3805 _HAL_AUDIO_SPDIF_SetMute(TRUE);
3806 }
3807 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3808 {
3809 //TODO: Mute HDMI , ARC
3810 }
3811 else if (ePath == DIGITAL_HDMI_OUTPUT)
3812 {
3813
3814 }
3815
3816 ret = HAL_AUDIO_DigitalOut_GetChannelStatus(ePath, &stDigitalChannelStatus);
3817
3818 if (ret == FALSE)
3819 {
3820 HALAUDIO_ERROR("%s()- GetChannelStatus return FALSE!!\n",__FUNCTION__);
3821 return;
3822 }
3823
3824 switch (stDigitalOutSetting->eDigitalOutfMode)
3825 {
3826 case DIGITAL_OUT_PCM:
3827 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, FALSE);
3828 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3829 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3830
3831 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
3832 break;
3833
3834 case DIGITAL_OUT_DOLBYDIGITAL:
3835 if (stDigitalOutSetting->u8R2NonPcmSetting == 0x01)
3836 {
3837 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3838 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, TRUE);
3839 }
3840 else if (stDigitalOutSetting->u8R2NonPcmSetting == 0x02)
3841 {
3842 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3843 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, TRUE);
3844 }
3845
3846 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3847 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3848 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3849 break;
3850
3851 case DIGITAL_OUT_DTS:
3852 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3853 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3854 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3855 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3856 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3857 break;
3858
3859 case DIGITAL_OUT_AAC_LC:
3860 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3861 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3862 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3863 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3864 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3865 break;
3866
3867 case DIGITAL_OUT_NONE:
3868 default:
3869 HALAUDIO_ERROR("%s() - Digital Mode %d not exist\n",__FUNCTION__,stDigitalOutSetting->eDigitalOutfMode);
3870 break;
3871 }
3872
3873 HAL_AUDIO_DigitalOut_SetChannelStatus(ePath, &stDigitalChannelStatus);
3874 // Restore Digital out mode
3875 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), &stDigitalOutSetting, sizeof(DigitalOutSetting_t));
3876
3877 if (ePath == DIGITAL_SPDIF_OUTPUT)
3878 {
3879 if (g_AudioVars2->g_SPDIF_MuteStatus == FALSE)
3880 {
3881 _HAL_AUDIO_SPDIF_SetMute(FALSE);
3882 }
3883 }
3884 else
3885 {
3886 //TODO: um-Mute HDMI , ARC
3887 }
3888
3889 }
3890
3891
3892
3893 //static MS_BOOL HAL_AUDIO_DigitalOut_GetDataSource(AUDIO_OUTPORT_SOURCE_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE *retOutputType, AUDIO_DSP_ID *retNcmPath)
3894
HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSegtting)3895 static MS_BOOL HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSegtting)
3896 {
3897 AUDIO_DSP_CODE_TYPE SourceDspCodeType = AU_DVB_STANDARD_INVALID;
3898 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
3899 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
3900
3901 stDigitalOutSegtting->eSourceType = g_AudioVars2->eAudioSource;
3902 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3903 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3904
3905 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x , Source = %x, R2NonPcmSetting = %x\n\r", \
3906 __FUNCTION__, \
3907 stDigitalOutSegtting->eDigitalOutfMode, \
3908 stDigitalOutSegtting->u8NonPcmPath, \
3909 stDigitalOutSegtting->eSourceType, \
3910 stDigitalOutSegtting->u8R2NonPcmSetting);
3911
3912 switch (stDigitalOutSegtting->eDigitalOutfMode)
3913 {
3914 case DIGITAL_OUT_PCM:
3915 {
3916 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3917 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC;
3918 break;
3919 }
3920
3921 case DIGITAL_OUT_DOLBYDIGITAL:
3922 {
3923 switch (stDigitalOutSegtting->eSourceType)
3924 {
3925 case E_AUDIO_INFO_HDMI_IN:
3926 {
3927 if (bIsNonPCMInDec2)
3928 {
3929 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) &&
3930 (Dsp2CodeType == AU_DVB2_STANDARD_AC3P_AD))
3931 {
3932 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3933 }
3934 }
3935 else if ((Dsp1CodeType == AU_DVB_STANDARD_AC3) ||
3936 (Dsp1CodeType == AU_DVB_STANDARD_AC3P))
3937 {
3938 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3939 }
3940 break;
3941 }
3942
3943 case E_AUDIO_INFO_DTV_IN:
3944 case E_AUDIO_INFO_MM_IN:
3945 case E_AUDIO_INFO_GAME_IN:
3946 {
3947 SourceDspCodeType = Dsp1CodeType;
3948
3949 switch(SourceDspCodeType)
3950 {
3951 case AU_DVB_STANDARD_AAC:
3952 case AU_DVB_STANDARD_MS10_DDT:
3953 {
3954 if ((!MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_MS10_DDT)) &&
3955 (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DDE)))
3956 {
3957 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3958 }
3959 else
3960 {
3961 if (HAL_MAD_Read_DSP_sram(DSP1PmAddr_smpRate, DSP_MEM_TYPE_PM) == 44100)
3962 {
3963 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3964 }
3965 else
3966 {
3967 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_R2; /* R2 */
3968 stDigitalOutSegtting->u8R2NonPcmSetting = (SourceDspCodeType == AU_DVB_STANDARD_AAC) ? 0x01 : 0x02; /* DDCO : 0x2E95[0], DDEnc : 0x2E95[1] */
3969 }
3970 }
3971
3972 break;
3973 }
3974
3975 case AU_DVB_STANDARD_MS10_DDC:
3976 case AU_DVB_STANDARD_AC3:
3977 case AU_DVB_STANDARD_AC3P:
3978 {
3979 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3980 break;
3981 }
3982
3983 default:
3984 {
3985 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3986 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3987 break;
3988 }
3989
3990 }
3991
3992 break;
3993 }
3994
3995 case E_AUDIO_INFO_ATV_IN:
3996 case E_AUDIO_INFO_ADC_IN:
3997 case E_AUDIO_INFO_KTV_IN:
3998 default:
3999 {
4000 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4001 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4002 break;
4003 }
4004 }
4005 break;
4006 }
4007
4008 case DIGITAL_OUT_DTS:
4009 {
4010 switch (stDigitalOutSegtting->eSourceType)
4011 {
4012 case E_AUDIO_INFO_HDMI_IN:
4013 {
4014 if (bIsNonPCMInDec2)
4015 {
4016 if (Dsp2CodeType == AU_DVB2_STANDARD_DTS) // Need check
4017 {
4018 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
4019 }
4020 }
4021 else if (Dsp1CodeType == AU_DVB_STANDARD_DTS)
4022 {
4023 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4024 }
4025 break;
4026 }
4027
4028 case E_AUDIO_INFO_MM_IN:
4029 case E_AUDIO_INFO_GAME_IN:
4030 {
4031 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_DTS;
4032 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4033 break;
4034 }
4035
4036 default:
4037 {
4038 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4039 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4040 break;
4041 }
4042 }
4043
4044 break;
4045 }
4046
4047 case DIGITAL_OUT_AAC_LC:
4048 {
4049 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4050 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4051 break;
4052 }
4053
4054 case DIGITAL_OUT_NONE:
4055 default:
4056 {
4057 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4058 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4059 break;
4060 }
4061
4062 }
4063
4064 return TRUE;
4065 }
4066
4067 ////////////////////////////////////////////////////////////////////////////////
4068 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4069 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4070 /// @param <IN> \b
4071 /// @param <IN> \b
4072 /// @param <OUT> \b NONE :
4073 /// @param <RET> \b NONE :
4074 /// @param <GLOBAL> \b NONE :
4075 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)4076 void HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)
4077 {
4078
4079 HALAUDIO_CHECK_SHM_INIT;
4080
4081 //TODO: add HDMI/ARC digital out status
4082
4083 // Set Digital mode to Digital out Status structure
4084 DigitalOutSetting_t stTempDigitalOutStatus;
4085 stTempDigitalOutStatus.eDigitalOutfMode = eDigitalMode;
4086 stTempDigitalOutStatus.eSourceType = E_AUDIO_INFO_DTV_IN; // Temp initial value
4087 stTempDigitalOutStatus.u8NonPcmPath = AUDIO_DSP_ID_ALL;
4088 stTempDigitalOutStatus.u8R2NonPcmSetting = 0x00;
4089 stTempDigitalOutStatus.eGroup = E_CONNECT_NULL;
4090
4091 if (ePath == DIGITAL_SPDIF_OUTPUT)
4092 {
4093 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.SpdifOut;
4094 }
4095 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
4096 {
4097 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.ArcOut;
4098 }
4099
4100 //Determin Data Path
4101 HAL_AUDIO_DigitalOut_DetermineDataPath(ePath, &stTempDigitalOutStatus);
4102
4103 // if setting is difference to previous, set digital out mode
4104 if ((stTempDigitalOutStatus.eDigitalOutfMode != g_AudioVars2->stDigitalOutSetting[ePath].eDigitalOutfMode) ||
4105 (stTempDigitalOutStatus.eSourceType != g_AudioVars2->stDigitalOutSetting[ePath].eSourceType) ||
4106 (stTempDigitalOutStatus.u8NonPcmPath != g_AudioVars2->stDigitalOutSetting[ePath].u8NonPcmPath) ||
4107 (stTempDigitalOutStatus.u8R2NonPcmSetting != g_AudioVars2->stDigitalOutSetting[ePath].u8R2NonPcmSetting) ||
4108 (stTempDigitalOutStatus.eGroup != g_AudioVars2->stDigitalOutSetting[ePath].eGroup))
4109
4110 {
4111 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x\n\r", \
4112 __FUNCTION__, \
4113 stTempDigitalOutStatus.eDigitalOutfMode, \
4114 stTempDigitalOutStatus.u8NonPcmPath);
4115
4116 HAL_AUDIO_DigitalOut_SetDataPath(ePath, &stTempDigitalOutStatus);
4117 }
4118 }
4119
4120 ////////////////////////////////////////////////////////////////////////////////
4121 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
4122 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4123 /// @param <IN> \b eType :
4124 /// @param <OUT> \b NONE :
4125 /// @param <RET> \b NONE :
4126 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)4127 MS_BOOL HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
4128 {
4129 MS_BOOL ret = FALSE;
4130
4131 HALAUDIO_CHECK_SHM_INIT;
4132
4133 switch (ePath)
4134 {
4135 case DIGITAL_SPDIF_OUTPUT:
4136 {
4137
4138 // Copy protection
4139 //C bit
4140 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
4141 // L bit
4142 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
4143
4144 // PCM format
4145 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
4146 if(g_u32bDTSCD == 1)
4147 {
4148 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x40, 0x00);
4149 }
4150
4151 // Category
4152 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
4153
4154 // Source number
4155 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
4156
4157 // Channel number
4158 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
4159
4160 // Sampling rate
4161 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
4162
4163 // Clock precision
4164 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
4165
4166 // Word Length
4167 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
4168
4169 // Original sampling rate
4170 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
4171
4172 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
4173 {
4174 if(g_u32bDTSCD == 1)
4175 {
4176 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
4177 }
4178 else
4179 {
4180 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x80);
4181 }
4182 }
4183 else
4184 {
4185 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
4186 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
4187 }
4188
4189 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00); //Tx1 Toggle bit[14]
4190 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x40);
4191 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00);
4192 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
4193 break;
4194 }
4195
4196 case DIGITAL_HDMI_ARC_OUTPUT:
4197 {
4198 // Copy protection
4199 //C bit
4200 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
4201 // L bit
4202 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
4203
4204 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
4205 if(g_u32bDTSCD == 1)
4206 {
4207 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x40, 0x00);
4208 }
4209
4210 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
4211
4212 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
4213
4214 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
4215
4216 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
4217
4218 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
4219
4220 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
4221
4222 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
4223
4224 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
4225 {
4226 if(g_u32bDTSCD == 1)
4227 {
4228 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
4229 }
4230 else
4231 {
4232 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x80);
4233 }
4234 }
4235 else
4236 {
4237 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
4238 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
4239 }
4240 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
4241 break;
4242 }
4243
4244 default:
4245 {
4246 HALAUDIO_ERROR("%s() - Invalid SPDIF Path\n",__FUNCTION__);
4247 break;
4248 }
4249 }
4250
4251 return ret;
4252 }
4253
4254 ////////////////////////////////////////////////////////////////////////////////
4255 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
4256 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4257 /// @param <IN> \b eType :
4258 /// @param <OUT> \b NONE :
4259 /// @param <RET> \b NONE :
4260 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)4261 MS_BOOL HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
4262 {
4263 MS_BOOL ret = FALSE;
4264
4265 HALAUDIO_CHECK_SHM_INIT;
4266
4267 if (stChannelStatus == NULL)
4268 {
4269 HALAUDIO_ERROR("%s() : stChannelStatus shouldn't be NULL !!!\n", __FUNCTION__);
4270 }
4271 else
4272 {
4273 memcpy(stChannelStatus, &(g_AudioVars2->stDigitalOutChannelStatus[ePath]), sizeof(Digital_Out_Channel_Status_t));
4274 ret = TRUE;
4275 }
4276
4277 return ret;
4278 }
4279
4280 ///-----------------------------------------------------------------------------
4281 ////////////////////////////////////////////////////////////////////////////////
4282 ////////////////////////////////////////////////////////////////////////////////
4283 ///
4284 /// AUDIO SPDIF Relational Hal Function
4285 ///
4286 ////////////////////////////////////////////////////////////////////////////////
4287 ////////////////////////////////////////////////////////////////////////////////
4288 ///-----------------------------------------------------------------------------
4289 ////////////////////////////////////////////////////////////////////////////////
4290 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_HWEN() @@Cathy
4291 /// @brief \b Function \b Description: This routine is used to enable S/PDIF output (Hardware)
4292 /// @param <IN> \b bEnable: 0--Disable S/PDIF out
4293 /// 1--Enable S/PDIF out
4294 /// @param <OUT> \b NONE :
4295 /// @param <RET> \b NONE :
4296 /// @param <GLOBAL> \b NONE :
4297 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)4298 void _HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)
4299 {
4300 if(bEnable)
4301 {
4302 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x80);
4303 }
4304 else
4305 {
4306 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00);
4307 }
4308 }
4309
4310 ////////////////////////////////////////////////////////////////////////////////
4311 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_SetMute() @@KH
4312 /// @brief \b Function \b Description: This routine is used to mute S/PDIF output(by DSP)
4313 /// @param <IN> \b bEnMute : 0--Disable mute
4314 /// 1--Enable mute
4315 /// @param <OUT> \b NONE :
4316 /// @param <RET> \b NONE :
4317 /// @param <GLOBAL> \b NONE :
4318 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)4319 void _HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)
4320 {
4321 MS_BOOL spdif_mute_status = FALSE;
4322 MS_U8 spdif_timecnt = 0;
4323
4324 HALAUDIO_CHECK_SHM_INIT;
4325
4326 /* check current status according to SPDIF Software mute bit */
4327 spdif_mute_status = (((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL) & 0x01) > 0) ? TRUE : FALSE);
4328
4329 /* apply change only when it's a different status from current status */
4330 if (spdif_mute_status != bEnMute)
4331 {
4332 if (bEnMute == TRUE)
4333 {
4334 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
4335 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x01); // Software mute
4336 }
4337 else
4338 {
4339 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x00); // Software unmute
4340 for (spdif_timecnt = 0; spdif_timecnt < 30; spdif_timecnt++)
4341 {
4342 AUDIO_DELAY1MS(1);
4343 }
4344 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
4345 }
4346 }
4347
4348 }
4349
4350 ////////////////////////////////////////////////////////////////////////////////
4351 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_ByPassChannel() @@Need_Modify
4352 /// @brief \b Function \b Description: ByPass the SPDIF channel (CH4)
4353 /// @param <IN> \b \b enable : TRUE --BYPASS CH4
4354 /// FALSE--OPEN CH4
4355 /// @param <OUT> \b NONE :
4356 /// @param <RET> \b NONE :
4357 /// @param <GLOBAL> \b NONE :
4358 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)4359 void _HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)
4360 {
4361 UNUSED(bEnable);
4362 }
4363
4364 ////////////////////////////////////////////////////////////////////////////////
4365 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4366 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4367 /// @param <IN> \b u8Spdif_mode :
4368 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
4369 /// bit[1] = 0: PCM mode, 1: non-PCM mode
4370 /// bit[2] = 1: non-PCM NULL Payload
4371 /// @param <IN> \b u8Input_src 0 : DTV
4372 /// 1 : ATV
4373 /// 2 : HDMI
4374 /// 3 : ADC
4375 /// 4 : CardReader
4376 /// 5 : SPDIF
4377 /// @param <OUT> \b NONE :
4378 /// @param <RET> \b NONE :
4379 /// @param <GLOBAL> \b NONE :
4380 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode,MS_U8 u8Input_src)4381 void HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode, MS_U8 u8Input_src)
4382 {
4383 // Multiple npcm source, still need total rework
4384 AUDIO_SOURCE_INFO_TYPE eAudioSource = -1;
4385 MS_U8 u8SpdifMode = ((u8Spdif_mode == SPDIF_OUT_NONE) ? SPDIF_OUT_PCM : u8Spdif_mode);
4386 MS_U8 u8R2SpdifMode = ((u8SpdifMode == SPDIF_OUT_PCM) ? 1 : 2);
4387 AUDIO_DSP_CODE_TYPE MainDspCodeType = MSAPI_AUD_DVB_INVALID;
4388 AUDIO_DSP_CODE_TYPE Dsp1CodeType = MSAPI_AUD_DVB_INVALID;
4389 AUDIO_DSP_CODE_TYPE Dsp2CodeType = MSAPI_AUD_DVB_INVALID;
4390 MS_U32 u32bDTSCD = 0;
4391 MS_U8 NonPcmPath = ADEC1; /* R2: ADEC1, ADEC2 */
4392
4393 HALAUDIO_CHECK_SHM_INIT;
4394 static MS_U32 u32bPreDTSCD = 0xFF;
4395
4396 UNUSED(u8Input_src);
4397 eAudioSource = g_AudioVars2->eAudioSource;
4398 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
4399 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
4400
4401 MainDspCodeType = Dsp1CodeType;
4402 NonPcmPath = ADEC1;
4403 //HALAUDIO_ERROR("%s: u8Spdif_mode = %d, eAudioSource = %d, u8Dsp1CodeType = %d, u8Dsp2CodeType = %d, u8Input_src = %d\r\n", __FUNCTION__, u8Spdif_mode, eAudioSource, u8Dsp1CodeType, u8Dsp2CodeType, u8Input_src);
4404
4405 /* Configure SPDIF's Output Setting */
4406 switch(eAudioSource)
4407 {
4408 case E_AUDIO_INFO_DTV_IN:
4409 case E_AUDIO_INFO_MM_IN:
4410 case E_AUDIO_INFO_GAME_IN:
4411 {
4412 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
4413 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
4414 {
4415 MainDspCodeType = Dsp2CodeType;
4416 NonPcmPath = ADEC2; //DEC2
4417 }
4418
4419 switch(MainDspCodeType)
4420 {
4421 case AU_DVB_STANDARD_AAC:
4422 case AU_DVB_STANDARD_MS10_DDT:
4423 {
4424 if (g_AudioVars2->DolbyEncFlag != 1)
4425 {
4426 u8SpdifMode = SPDIF_OUT_PCM;
4427 }
4428 #if (StereoAACOutputPCM)
4429 else if (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod) == AUD_CH_MODE_STEREO)
4430 {
4431 u8SpdifMode = SPDIF_OUT_PCM;
4432 }
4433 #endif
4434 else
4435 {
4436 if ((u8SpdifMode == SPDIF_OUT_NONPCM) ||
4437 (u8SpdifMode == SPDIF_OUT_TRANSCODE))
4438 {
4439 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, ADEC1, 0, 0);
4440 }
4441 else if (u8SpdifMode == SPDIF_OUT_BYPASS) // AAC Bypass
4442 {
4443 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, ADEC1, 1, 0);
4444 }
4445 }
4446 break;
4447 }
4448
4449 case AU_DVB_STANDARD_AC3:
4450 case AU_DVB_STANDARD_AC3P:
4451 case AU_DVB_STANDARD_MS10_DDC:
4452 {
4453 break;
4454 }
4455 case AU_DVB_STANDARD_DTS:
4456 {
4457 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4458 break;
4459 }
4460
4461 case AU_DVB_STANDARD_DTSLBR:
4462 {
4463 if (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DTSE))
4464 {
4465 u8SpdifMode = SPDIF_OUT_PCM;
4466 }
4467 break;
4468 }
4469
4470 default:
4471 {
4472 u8SpdifMode = SPDIF_OUT_PCM;
4473 break;
4474 }
4475 }
4476
4477 break;
4478 }
4479
4480 case E_AUDIO_INFO_ATV_IN:
4481 case E_AUDIO_INFO_ADC_IN:
4482 case E_AUDIO_INFO_KTV_IN:
4483 {
4484 u8SpdifMode = SPDIF_OUT_PCM;
4485 break;
4486 }
4487
4488 case E_AUDIO_INFO_HDMI_IN:
4489 {
4490 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
4491 {
4492 MainDspCodeType = Dsp2CodeType;
4493 NonPcmPath = ADEC2; //DEC2
4494 }
4495 else
4496 {
4497 MainDspCodeType = Dsp1CodeType;
4498 NonPcmPath = ADEC1; //DEC1
4499 }
4500
4501 if (Dsp1CodeType == AU_DVB_STANDARD_DTS)
4502 {
4503 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4504 }
4505
4506 if (HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE)
4507 {
4508 u8SpdifMode = SPDIF_OUT_PCM;
4509 }
4510
4511 break;
4512 }
4513
4514 default:
4515 {
4516 HALAUDIO_ERROR("%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
4517 break;
4518 }
4519 }
4520
4521 //HALAUDIO_ERROR("%s: u8MainDspCodeType = %d, u8SpdifMode = %d\r\n", __FUNCTION__, u8MainDspCodeType, u8SpdifMode);
4522
4523 if ((_HAL_AUDIO_SPDIF_GetMode() == u8SpdifMode) &&
4524 (u32bPreDTSCD == u32bDTSCD))
4525 {
4526 return;
4527 }
4528 u32bPreDTSCD = u32bDTSCD;
4529
4530 //Change multi channel input source for DTS encode
4531 if( (eAudioSource == E_AUDIO_INFO_HDMI_IN) && (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) )
4532 {
4533 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x02);
4534 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x02);
4535 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x02);
4536 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x02);
4537 }
4538 else
4539 {
4540 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x00);
4541 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x00);
4542 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x00);
4543 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x00);
4544 }
4545
4546 MS_BOOL retTx1, retTx2;
4547 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4548 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4549 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4550 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4551 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4552
4553 if (retTx1 == FALSE || retTx2 == FALSE)
4554 {
4555 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4556 return;
4557 }
4558
4559 /* Mute SPDIF before changing setting */
4560 _HAL_AUDIO_SPDIF_SetMute(TRUE);
4561
4562 /* Apply UI's SPDIF setting to Audio R2 */
4563 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC1, u8R2SpdifMode, 0);
4564 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC2, u8R2SpdifMode, 0);
4565
4566 /* Apply SPDIF's Output Setting */
4567 switch (u8SpdifMode)
4568 {
4569 case SPDIF_OUT_NONPCM:
4570 case SPDIF_OUT_BYPASS:
4571 case SPDIF_OUT_TRANSCODE:
4572 {
4573 //HALAUDIO_PRINT("HAL SPDIF set as Non-PCM\n");
4574
4575 HAL_AUR2_WriteByte(REG_R2_HDMI_NONPCM_PATH, NonPcmPath);
4576 AUDIO_DELAY1MS(5);
4577 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
4578 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
4579 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4580 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4581 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4582 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4583 AUDIO_DELAY1MS(5);
4584 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x02, 0x02); /* Non-PCM */
4585
4586 break;
4587 }
4588
4589 case SPDIF_OUT_PCM:
4590 default:
4591 {
4592 //HALAUDIO_PRINT("HAL SPDIF set as PCM\n");
4593
4594 AUDIO_DELAY1MS(5);
4595 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
4596 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
4597 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4598 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4599 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4600
4601 break;
4602 }
4603 }
4604
4605 g_u32bDTSCD = u32bDTSCD;
4606
4607 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4608 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4609
4610 g_AudioVars2->g_eSpdifOutputType = u8SpdifMode;
4611 _HAL_AUDIO_SPDIF_SetMute(g_AudioVars2->g_SPDIF_MuteStatus);
4612 }
4613
4614 ////////////////////////////////////////////////////////////////////////////////
4615 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_GetMode() @@KH
4616 /// @brief \b Function \b Description: This routine is used to get S/PDIF mode.
4617 /// @param <IN> \b NONE :
4618 /// @param <OUT> \b NONE :
4619 /// @param <RET> \b BYTE : Se-DSP REG_M2D_MAILBOX_SPDIF_CTRL value
4620 /// u8Spdif_mode = 0x0 : SPDIF enable, PCM mode
4621 /// u8Spdif_mode = 0x1 : SPDIF OFF
4622 /// u8Spdif_mode = 0x2 : SPDIF enable, non-PCM mode
4623 /// @param <GLOBAL> \b NONE :
4624 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_GetMode(void)4625 MS_U8 _HAL_AUDIO_SPDIF_GetMode(void)
4626 {
4627 return g_AudioVars2->g_eSpdifOutputType;
4628 }
4629
4630 ////////////////////////////////////////////////////////////////////////////////
4631 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetSCMS()
4632 /// @brief \b Function \b Description: This routine is used to set SPDIF SCMS.
4633 /// @param C_bit_en \b : copy right control bit, register in 0x2C80[5]
4634 /// @param L_bit_en \b : generation bit, register in 0x2C82[7]
4635 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en,MS_U8 L_bit_en)4636 void HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en, MS_U8 L_bit_en)
4637 {
4638 MS_BOOL retTx1, retTx2;
4639
4640 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4641 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4642 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4643 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4644 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4645
4646 if (retTx1 == TRUE && retTx2 == TRUE)
4647 {
4648 stDigitalChannelStatusTx1.stCopyRight.CBit = C_bit_en;
4649 stDigitalChannelStatusTx1.stCopyRight.LBit = L_bit_en;
4650 stDigitalChannelStatusTx2.stCopyRight.CBit = C_bit_en;
4651 stDigitalChannelStatusTx2.stCopyRight.LBit = L_bit_en;
4652 }
4653 else
4654 {
4655 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4656 return;
4657 }
4658
4659 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4660 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4661 }
4662
4663 ////////////////////////////////////////////////////////////////////////////////
4664 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_GetSCMS()
4665 /// @brief \b Function \b Description: This routine is used to get SPDIF SCMS.
4666 /// @return MS_U8 \b : SCMS[0] = C bit status, SCMS[1] = L bit status
4667 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_GetSCMS(void)4668 MS_U8 HAL_AUDIO_SPDIF_GetSCMS(void)
4669 {
4670
4671 MS_U8 SCMS_status, SCMS_C_bit_tmp, SCMS_L_bit_tmp;
4672
4673 HALAUDIO_CHECK_SHM_INIT;
4674
4675 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.CBit)
4676 {
4677 SCMS_C_bit_tmp = 0x01;
4678 }
4679 else
4680 {
4681 SCMS_C_bit_tmp = 0x00;
4682 }
4683
4684 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.LBit)
4685 {
4686 SCMS_L_bit_tmp = 0x02;
4687 }
4688 else
4689 {
4690 SCMS_L_bit_tmp = 0x00;
4691 }
4692
4693 SCMS_status = SCMS_C_bit_tmp | SCMS_L_bit_tmp;
4694
4695 return(SCMS_status);
4696 }
4697
4698 ////////////////////////////////////////////////////////////////////////////////
4699 /// @brief \b Function \b Name: HAL_AUDIO_SetChannelStatus()
4700 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4701 /// @param <IN> \b eType :
4702 /// @param <OUT> \b NONE :
4703 /// @param <RET> \b NONE :
4704 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType,SPDIF_CS_MODE_VALUE eValue)4705 void HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType, SPDIF_CS_MODE_VALUE eValue)
4706 {
4707 MS_U8 u8Type;
4708
4709 u8Type=(MS_U8)eType;
4710
4711 MS_BOOL retTx1, retTx2;
4712 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4713 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4714 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4715 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4716 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4717
4718
4719 if (retTx1 == FALSE || retTx2 == FALSE)
4720 {
4721 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4722 return;
4723 }
4724
4725 switch(u8Type)
4726 {
4727 case SPDIF_CHANNEL_STATUS_FS:
4728 stDigitalChannelStatusTx1.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx1
4729 stDigitalChannelStatusTx2.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx2
4730 break;
4731 case SPDIF_CHANNEL_STATUS_CATEGORY:
4732 stDigitalChannelStatusTx1.u8Category = (MS_U8)eValue; // Tx1 By-pass L- bit
4733 stDigitalChannelStatusTx2.u8Category = (MS_U8)eValue; // Tx2 By-pass L- bit
4734 break;
4735 case SPDIF_CHANNEL_STATUS_PCM_FORMAT:
4736 stDigitalChannelStatusTx1.u8PcmFormatControl = (MS_U8)eValue; // Tx1 By-pass Copy right bit
4737 stDigitalChannelStatusTx2.u8PcmFormatControl = (MS_U8)eValue; // Tx2 By-pass Copy right bit
4738 break;
4739
4740 default :
4741 break;
4742 }
4743
4744 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4745 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4746 }
4747
4748 ////////////////////////////////////////////////////////////////////////////////
4749 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_ChannelStatus_CTRL()
4750 /// @brief \b Function \b Description: This routine is used to control SPDIF CS in detail.
4751 /// @return MS_U8 \b :
4752 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode,AUDIO_SPDIF_CS_TYPE_STATUS status)4753 MS_BOOL HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode, AUDIO_SPDIF_CS_TYPE_STATUS status)
4754 {
4755 MS_BOOL status_rtn = FALSE;
4756 MS_BOOL retTx1, retTx2;
4757
4758 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4759 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4760 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4761 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4762 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4763
4764 if (retTx1 == FALSE || retTx2 == FALSE)
4765 {
4766 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4767 return status_rtn;
4768 }
4769
4770 switch (cs_mode)
4771 {
4772 case SPDIF_CS_CategoryCode:
4773 switch(status)
4774 {
4775 case SPDIF_CS_Category_BroadCast:
4776 stDigitalChannelStatusTx1.u8Category = 0x20;
4777 stDigitalChannelStatusTx2.u8Category = 0x20;
4778 break;
4779
4780 case SPDIF_CS_Category_General:
4781 stDigitalChannelStatusTx1.u8Category = 0x00;
4782 stDigitalChannelStatusTx2.u8Category = 0x00;
4783 break;
4784
4785 case SPDIF_CS_Category_BroadCast_JP:
4786 stDigitalChannelStatusTx1.u8Category = 0x20;
4787 stDigitalChannelStatusTx2.u8Category = 0x20;
4788 break;
4789
4790 case SPDIF_CS_Category_BroadCast_EU:
4791 stDigitalChannelStatusTx1.u8Category = 0x30;
4792 stDigitalChannelStatusTx2.u8Category = 0x30;
4793 break;
4794
4795 case SPDIF_CS_Category_BroadCast_USA:
4796 stDigitalChannelStatusTx1.u8Category = 0x26;
4797 stDigitalChannelStatusTx2.u8Category = 0x26;
4798 break;
4799
4800 default :
4801 stDigitalChannelStatusTx1.u8Category = 0x00;
4802 stDigitalChannelStatusTx2.u8Category = 0x00;
4803 break;
4804 }
4805 status_rtn = TRUE;
4806 break;
4807
4808 case SPDIF_CS_CopyRight:
4809 if(status == SPDIF_CS_CopyRight_CP)
4810 {
4811 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4812 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4813 }
4814 if(status == SPDIF_CS_CopyRight_NonCP)
4815 {
4816 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4817 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4818 }
4819 status_rtn = TRUE;
4820 break;
4821
4822 case SPDIF_CS_SourceNumber:
4823 if(status == SPDIF_CS_SourceNumber_2)
4824 {
4825 stDigitalChannelStatusTx1.u8SourceNumber = 0x40;
4826 stDigitalChannelStatusTx2.u8SourceNumber = 0x40;
4827 }
4828 if(status == SPDIF_CS_SourceNumber_5)
4829 {
4830 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4831 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4832 }
4833 if(status == SPDIF_CS_SourceNumber_6)
4834 {
4835 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4836 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4837 }
4838 status_rtn = TRUE;
4839 break;
4840
4841 case SPDIF_CS_ChannelNumber:
4842 if(status == SPDIF_CS_ChannelNumber_A_Left)
4843 {
4844 stDigitalChannelStatusTx1.u8ChannelNumber = 0x08;
4845 stDigitalChannelStatusTx2.u8ChannelNumber = 0x08;
4846 }
4847 if(status == SPDIF_CS_ChannelNumber_B_Right)
4848 {
4849 stDigitalChannelStatusTx1.u8ChannelNumber = 0x04;
4850 stDigitalChannelStatusTx2.u8ChannelNumber = 0x04;
4851 }
4852 if(status == SPDIF_CS_ChannelNumber_C)
4853 {
4854 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0C;
4855 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0C;
4856 }
4857 if(status == SPDIF_CS_ChannelNumber_D)
4858 {
4859 stDigitalChannelStatusTx1.u8ChannelNumber = 0x02;
4860 stDigitalChannelStatusTx2.u8ChannelNumber = 0x02;
4861 }
4862 if(status == SPDIF_CS_ChannelNumber_E)
4863 {
4864 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0A;
4865 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0A;
4866 }
4867 if(status == SPDIF_CS_ChannelNumber_F)
4868 {
4869 stDigitalChannelStatusTx1.u8ChannelNumber = 0x06;
4870 stDigitalChannelStatusTx2.u8ChannelNumber = 0x06;
4871 }
4872 status_rtn = TRUE;
4873 break;
4874
4875 case SPDIF_CS_SmpFreq:
4876 switch (status)
4877 {
4878 case SPDIF_CS_SmpFreq_192:
4879 stDigitalChannelStatusTx1.u8SamplingRate = 0x70;
4880 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
4881 break;
4882
4883 case SPDIF_CS_SmpFreq_96:
4884 stDigitalChannelStatusTx1.u8SamplingRate = 0x50;
4885 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
4886 break;
4887
4888 case SPDIF_CS_SmpFreq_48:
4889 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
4890 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
4891 break;
4892
4893 case SPDIF_CS_SmpFreq_176:
4894 stDigitalChannelStatusTx1.u8SamplingRate = 0x30;
4895 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
4896 break;
4897
4898 case SPDIF_CS_SmpFreq_88:
4899 stDigitalChannelStatusTx1.u8SamplingRate = 0x10;
4900 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
4901 break;
4902
4903 case SPDIF_CS_SmpFreq_44:
4904 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4905 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4906 break;
4907
4908 case SPDIF_CS_SmpFreq_64:
4909 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4910 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4911 break;
4912
4913 case SPDIF_CS_SmpFreq_32:
4914 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
4915 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
4916 break;
4917
4918 default:
4919 status_rtn = FALSE;
4920 break;
4921 }
4922 status_rtn = TRUE;
4923 break;
4924
4925 case SPDIF_CS_ClockAcc:
4926 status_rtn = TRUE;
4927 break;
4928
4929 case SPDIF_ChannelAB:
4930 if (status == SPDIF_ChannelAB_Invalid_ON)
4931 {
4932 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx1 Invalid bit=high in non-PCM mode
4933 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx2 Invalid bit=high in non-PCM mode
4934 }
4935 if (status == SPDIF_ChannelAB_Invalid_OFF)
4936 {
4937 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx1 Invalid bit=low in PCM mode
4938 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx2 Invalid bit=low in PCM mode
4939 }
4940 status_rtn = TRUE;
4941 break;
4942
4943 case SPDIF_CS_CopyProtect:
4944 switch (status)
4945 {
4946 case SPDIF_CS_CopyProtect_CopyFree:
4947 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4948 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4949 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4950 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4951 status_rtn = TRUE;
4952 break;
4953
4954 case SPDIF_CS_CopyProtect_CopyOnce:
4955 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4956 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4957 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4958 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4959 status_rtn = TRUE;
4960 break;
4961
4962 case SPDIF_CS_CopyProtect_CopyNever:
4963 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4964 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
4965 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4966 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
4967 status_rtn = TRUE;
4968 break;
4969
4970 default:
4971 status_rtn = FALSE;
4972 break;
4973 }
4974 break;
4975
4976 default:
4977 status_rtn = FALSE;
4978 break;
4979
4980 }
4981
4982 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4983 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4984
4985 return(status_rtn);
4986 }
4987
4988 ////////////////////////////////////////////////////////////////////////////////
4989 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_Monitor_SamplingRate()
4990 /// @brief \b Function \b Description: This routine is to set ADC clock for SPDIF raw out
4991 /// @param <IN> \b NONE :
4992 /// @param <OUT> \b NONE :
4993 /// @param <RET> \b NONE :
4994 /// @param <GLOBAL> \b NONE :
4995 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)4996 void HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)
4997 {
4998 return;
4999 }
5000
5001 ////////////////////////////////////////////////////////////////////////////////
5002 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetOutputType()
5003 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
5004 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource,AUDIO_SPDIF_OUTPUT_TYPE eType)5005 void HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource, AUDIO_SPDIF_OUTPUT_TYPE eType)
5006 {
5007 UNUSED(eSource);
5008 UNUSED(eType);
5009 }
5010
5011 ///-----------------------------------------------------------------------------
5012 ////////////////////////////////////////////////////////////////////////////////
5013 ////////////////////////////////////////////////////////////////////////////////
5014 ///
5015 /// AUDIO HDMI Relational Hal Function
5016 ///
5017 ////////////////////////////////////////////////////////////////////////////////
5018 ////////////////////////////////////////////////////////////////////////////////
5019 ///-----------------------------------------------------------------------------
5020 ////////////////////////////////////////////////////////////////////////////////
5021 /// @brief \b Function \b Name: _HAL_AUDIO_HDMI_Tx_SetMute()
5022 /// @brief \b Function \b Description: This routine is used to mute HDMI Tx output(by DSP)
5023 /// @param <IN> \b bEnMute : 0--Disable mute
5024 /// 1--Enable mute
5025 /// @param <OUT> \b NONE :
5026 /// @param <RET> \b NONE :
5027 /// @param <GLOBAL> \b NONE :
5028 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)5029 void _HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)
5030 {
5031 if(bEnMute == 1)
5032 {
5033 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x80, 0x80); // Software Mute
5034 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
5035 }
5036 else
5037 {
5038 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x80, 0x00); // Software unMute
5039 MsOS_DelayTask(30);
5040 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
5041 }
5042 }
5043
5044 ////////////////////////////////////////////////////////////////////////////////
5045 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor()
5046 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status
5047 /// @param <IN> \b NONE :
5048 /// @param <OUT> \b NONE :
5049 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
5050 /// @param <GLOBAL> \b NONE :
5051 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor(void)5052 MS_BOOL HAL_AUDIO_HDMI_NonpcmMonitor(void)
5053 {
5054 MS_BOOL bHdmiNonPcmMode = FALSE;
5055 MS_U8 u8TargetPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
5056 MS_U8 u8CurrentPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
5057
5058 HAL_AUDIO_AbsWriteMaskByte(0x1027C8, 0x02, 0x02); // Add audio bank offset
5059 if (((HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_INPUT) & 0xC0) == 0x40) || (HAL_AUDIO_HDMI_NonpcmMonitor2() == 0x1))
5060 {
5061 u8TargetPcmRenderControl = 0; //decoder mode
5062 bHdmiNonPcmMode = TRUE;
5063 }
5064 else
5065 {
5066 u8TargetPcmRenderControl = 2; //stereo mode
5067 bHdmiNonPcmMode = FALSE;
5068 }
5069
5070 /* if current main input source is HDMI, then configure R2's PCM Render */
5071 if (g_AudioVars2->eAudioSource == E_AUDIO_INFO_HDMI_IN)
5072 {
5073 u8CurrentPcmRenderControl = (HAL_AUR2_ReadByte(REG_SNDR2_MBOX_BYTE_DAP_SEL) & 0x06) >> 1;
5074 if (u8TargetPcmRenderControl != u8CurrentPcmRenderControl)
5075 {
5076 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8TargetPcmRenderControl << 1));
5077 }
5078 }
5079
5080 return bHdmiNonPcmMode;
5081 }
5082
5083 ////////////////////////////////////////////////////////////////////////////////
5084 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor2()
5085 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status from DSP
5086 /// @param <IN> \b NONE :
5087 /// @param <OUT> \b NONE :
5088 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
5089 /// @param <GLOBAL> \b NONE :
5090 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor2(void)5091 MS_U8 HAL_AUDIO_HDMI_NonpcmMonitor2(void)
5092 {
5093 MS_U32 HDMI_lock_status_tmp;
5094 HDMI_lock_status_tmp = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_hdmi_npcm_lock);
5095 if (HDMI_lock_status_tmp == 0x30)
5096 {
5097 return (1);
5098 }
5099 else
5100 {
5101 return (0);
5102 }
5103 }
5104
5105 ////////////////////////////////////////////////////////////////////////////////
5106 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_DolbyMonitor() @@Need_Modify
5107 /// @brief \b Function \b Description: Report HDMI non-PCM Dolby mod status
5108 /// @param <IN> \b NONE :
5109 /// @param <OUT> \b NONE :
5110 /// @param <RET> \b u8DolbyModeType :
5111 /// 0-- Other mode
5112 /// 1-- Dolby mode
5113 /// @param <GLOBAL> \b NONE :
5114 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_DolbyMonitor(void)5115 MS_U8 HAL_AUDIO_HDMI_DolbyMonitor(void)
5116 {
5117 return HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_HDMI_PC);
5118 }
5119
5120 ////////////////////////////////////////////////////////////////////////////////
5121 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_SetNonpcm() @@Need_Modify
5122 /// @brief \b Function \b Description: Set HDMI PCM/non-PCM Mode
5123 /// @param <IN> \b nonPCM_en :
5124 /// -- 0: PCM mode
5125 /// -- 1: non-PCM mode
5126 /// @param <OUT> \b NONE :
5127 /// @param <RET> \b NONE :
5128 /// @param <GLOBAL> \b NONE :
5129 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)5130 void HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)
5131 {
5132 //=======================================================
5133 Hdmi_Input_Path HDMI_INPUT_PATH ;
5134 MS_BOOL bIsNonPCM= FALSE;
5135 MS_U8 u8DecoderType = 0;
5136
5137 bIsNonPCM = (MS_BOOL)(nonPCM_en & HDMI_NonPCM_Mask); // Use bit 1 mask check PCM/nonPCM
5138 HDMI_INPUT_PATH = (Hdmi_Input_Path)(nonPCM_en & HDMI_Input_Path_Mask); // Use bit2 mask check main or sub in PIP
5139
5140 if (bIsNonPCM) //====== HDMI nonpcm mode =======
5141 {
5142 u8DecoderType = HAL_AUDIO_HDMI_DolbyMonitor();
5143
5144 switch(u8DecoderType)
5145 {
5146 case AU_HDMI_DTS_TYPE1:
5147 case AU_HDMI_DTS_TYPE2:
5148 case AU_HDMI_DTS_TYPE3:
5149 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5150 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_DTS);
5151 else
5152 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_DTS);
5153
5154 break;
5155 case AU_HDMI_AC3:
5156 case AU_HDMI_AC3P:
5157 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5158 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_AC3);
5159 else
5160 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_AC3);
5161
5162 break;
5163 };
5164
5165 // Audio Input path config
5166 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5167 {
5168 // HDMI in 2nd Decoder
5169 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5170 {
5171 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_6);
5172 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5173 }
5174 else
5175 {
5176 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_MAIN);
5177 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5178 }
5179 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP); // Stop
5180 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG,0x07,0x04);
5181 MsOS_DelayTask(10);
5182 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_PLAY); // PlaY
5183 }
5184 else // HDMI in 1st Decoder
5185 {
5186 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5187 {
5188 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_6);
5189 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5190 }
5191 else
5192 {
5193 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_MAIN);
5194 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5195 }
5196
5197 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP); // Stop
5198 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04);
5199 MsOS_DelayTask(10);
5200 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_PLAY); // Play
5201 }
5202
5203 //========= Set for S/PDIF out ===========
5204 HAL_AUDIO_SPDIF_SetMode(_HAL_AUDIO_SPDIF_GetMode(), E_AUDIO_INFO_HDMI_IN);
5205
5206 //Byte swap setting
5207 if (HAL_AUDIO_HDMI_DolbyMonitor() == AU_HDMI_AC3P)
5208 {
5209 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 1, 0);
5210 }
5211 else
5212 {
5213 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 0, 0);
5214 }
5215 }
5216 else //====== HDMI pcm mode =======
5217 {
5218 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5219 {
5220 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_6);
5221 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x19);
5222 }
5223 else
5224 {
5225 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_MAIN);
5226 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x19);
5227 }
5228
5229 HAL_AUDIO_SPDIF_SetMode(SPDIF_OUT_PCM, E_AUDIO_INFO_HDMI_IN);
5230 }
5231
5232 }
5233
5234 ////////////////////////////////////////////////////////////////////////////////
5235 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_AC3_PathCFG() @@Need_Modify
5236 /// @brief \b Function \b Description: Set DVB/HDMI AC3 path Control
5237 /// @param <IN> \b u8Ctrl :
5238 /// -- 0: DVB2_AD path
5239 /// -- 1: HDMI path
5240 /// @param <OUT> \b NONE :
5241 /// @param <RET> \b NONE :
5242 /// @param <GLOBAL> \b NONE :
5243 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)5244 void HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)
5245 {
5246 if (u8Ctrl == 1)
5247 { // HDMI
5248 /* use CH1 decode HDMI AC3 */
5249 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04); // HDMI_AC3 REG CFG
5250 }
5251 else
5252 { // DTV
5253 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x00); // DVB1 REG CFG
5254 }
5255 }
5256
5257
5258 ////////////////////////////////////////////////////////////////////////////////
5259 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Get_SYNTH_FREQ() @@Need_Modify
5260 /// @brief \b Function \b Description: Audio HDMI CTS-N synthesizer input signal detect.
5261 /// @param <IN> \b NONE :
5262 /// @param <OUT> \b MS_U16 : return freq. If no signal, return 0
5263 /// @param <RET> \b NONE :
5264 /// @param <GLOBAL> \b NONE :
5265 ////////////////////////////////////////////////////////////////////////////////
5266
HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)5267 MS_U16 HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)
5268 {
5269 MS_U16 freq;
5270
5271 freq = HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH) + 0x100 * HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH+1);
5272
5273 if(freq & 0x8000)
5274 return 0; //no signal
5275
5276 return freq;
5277 }
5278
5279 ////////////////////////////////////////////////////////////////////////////////
5280 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Set_DwonSample() @@Cathy
5281 /// @brief \b Function \b Description: set HDMI downsample rate
5282 /// @param <IN> \b MS_U8 : donwsample ratio ; no need in T3
5283 /// @param <OUT> \b NONE :
5284 /// @param <RET> \b NONE :
5285 /// @param <GLOBAL> \b NONE :
5286 ////////////////////////////////////////////////////////////////////////////////
5287
HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)5288 void HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)
5289 {
5290 UNUSED(ratio); // No need in T3
5291 }
5292
5293
5294 ////////////////////////////////////////////////////////////////////////////////
5295 /// @brief \b Function \b Name: HAL_AUDIO_HDMIAutoMute() @@Need_Modify
5296 /// @brief \b Function \b This routine sets the automute function of HDMI.
5297 /// @param <IN> \b MS_U8 : ch : 0~5
5298 /// value: register value
5299 /// @param <OUT> \b NONE :
5300 /// @param <RET> \b NONE :
5301 /// @param <GLOBAL> \b NONE :
5302 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMIAutoMute(MS_U8 ch,MS_U8 value)5303 void HAL_AUDIO_HDMIAutoMute(MS_U8 ch, MS_U8 value)
5304 {
5305 if(ch < 4)
5306 {
5307 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+(ch<<1),value);
5308 }
5309 else if(ch == 4)
5310 {
5311 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+1,value);
5312 }
5313 else if(ch == 5)
5314 {
5315 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL2+1,value);
5316 }
5317 }
5318
5319 ////////////////////////////////////////////////////////////////////////////////
5320 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Tx_GetStatus()
5321 /// @brief \b Function \b Description: This routine is used to get HDMI Tx status
5322 /// @param onOff \b : HDMI tx function is availible in this chip ?
5323 /// @param hdmi_SmpFreq \b : Audio current sample freq for tx
5324 /// @param outType \b : PCM mode or nonPCM mode
5325 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL * onOff,AUDIO_FS_TYPE * hdmi_SmpFreq,HDMI_TX_OUTPUT_TYPE * outType)5326 void HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL *onOff, AUDIO_FS_TYPE *hdmi_SmpFreq, HDMI_TX_OUTPUT_TYPE *outType )
5327 {
5328 *onOff = TRUE;
5329 *hdmi_SmpFreq = (AUDIO_FS_TYPE)(HAL_MAD_GetCommInfo(Audio_Comm_infoType_hdmiTx_outFreq));
5330 *outType = (HDMI_TX_OUTPUT_TYPE)(HAL_MAD_GetCommInfo(Audio_Comm_infoType_hdmiTx_outType));
5331 }
5332
5333
5334
5335 ///-----------------------------------------------------------------------------
5336 ////////////////////////////////////////////////////////////////////////////////
5337 ////////////////////////////////////////////////////////////////////////////////
5338 ///
5339 /// AUDIO Internel Use Hal Function
5340 ///
5341 ////////////////////////////////////////////////////////////////////////////////
5342 ////////////////////////////////////////////////////////////////////////////////
5343 ///-----------------------------------------------------------------------------
5344
5345 ////////////////////////////////////////////////////////////////////////////////
5346 /// @brief \b Function \b Name: _HAL_AUDIO_InitStep1() @@Need_Modify
5347 /// @brief \b Function \b Description: This routine is the initialization for Audio module(Step1).
5348 /// @param <IN> \b NONE :
5349 /// @param <OUT> \b NONE :
5350 /// @param <RET> \b NONE :
5351 /// @param <GLOBAL> \b NONE :
5352 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_InitStep1(void)5353 void _HAL_AUDIO_InitStep1(void)
5354 {
5355 HAL_AUDIO_WriteInitTable();
5356 HAL_AUDIO_SetPowerOn(1);
5357 HAL_SIF_TriggerSifPLL();
5358
5359 HAL_AUDIO_SwResetMAD();
5360
5361 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0082);
5362 AUDIO_DELAY1MS(2);
5363 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0083);
5364 // Reset Audio MIU Request for DEC-DSP
5365 HAL_MAD_DisEn_MIUREQ();
5366
5367 }
5368
5369
5370 ////////////////////////////////////////////////////////////////////////////////
5371 /// @brief \b Function \b Name: HAL_AUDIO_SetDspBaseAddr()
5372 /// @brief \b Function \b Description: This function is used to set bin file base address in flash for Audio module.
5373 /// @param <IN> \b u8Index :
5374 /// @param <IN> \b Bin_Base_Address :
5375 /// @param <IN> \b Mad_Base_Buffer_Adr :
5376 /// @param <OUT> \b NONE :
5377 /// @param <RET> \b NONE :
5378 /// @param <GLOBAL> \b NONE :
5379 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index,MS_PHY phyBin_Base_Address,MS_PHY phyMad_Base_Buffer_Adr)5380 void HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index, MS_PHY phyBin_Base_Address, MS_PHY phyMad_Base_Buffer_Adr)
5381 {
5382 HALAUDIO_CHECK_SHM_INIT;
5383
5384 g_AudioVars2->g_DSPMadMIUBank[u8Index] = (MS_U8) (phyMad_Base_Buffer_Adr & 0x0000000F);
5385 phyMad_Base_Buffer_Adr &= 0xFFFFFFF0;
5386 switch(u8Index)
5387 {
5388 case(DSP_ADV): //DSP_ADV=R2=2
5389 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = phyBin_Base_Address; //R2 ADDR setting
5390 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = phyMad_Base_Buffer_Adr;
5391 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5392 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5393 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5394
5395 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = phyBin_Base_Address; //SE ADEC ADDR setting
5396 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = phyMad_Base_Buffer_Adr + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
5397 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5398 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
5399 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
5400
5401 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = phyBin_Base_Address; //Comm ADDR setting
5402 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
5403 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5404 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
5405 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
5406 break;
5407 default:
5408 UNUSED(u8Index);
5409 break;
5410 }
5411
5412 #ifndef MSOS_TYPE_NUTTX
5413 AUDIO_TEE_INFO_SHM_CHECK_NULL;
5414 REE_TO_TEE_MBX_MSG_SET_PARAM(0, u8Index);
5415 REE_TO_TEE_MBX_MSG_SET_PARAM(1, (MS_U8)(phyBin_Base_Address&0xFF));
5416 REE_TO_TEE_MBX_MSG_SET_PARAM(2, (MS_U8)((phyBin_Base_Address>>8)&0xFF));
5417 REE_TO_TEE_MBX_MSG_SET_PARAM(3, (MS_U8)((phyBin_Base_Address>>16)&0xFF));
5418 REE_TO_TEE_MBX_MSG_SET_PARAM(4, (MS_U8)((phyBin_Base_Address>>24)&0xFF));
5419 REE_TO_TEE_MBX_MSG_SET_PARAM(5, (MS_U8)(phyMad_Base_Buffer_Adr&0xFF));
5420 REE_TO_TEE_MBX_MSG_SET_PARAM(6, (MS_U8)((phyMad_Base_Buffer_Adr>>8)&0xFF));
5421 REE_TO_TEE_MBX_MSG_SET_PARAM(7, (MS_U8)((phyMad_Base_Buffer_Adr>>16)&0xFF));
5422 REE_TO_TEE_MBX_MSG_SET_PARAM(8, (MS_U8)((phyMad_Base_Buffer_Adr>>24)&0xFF));
5423 REE_TO_TEE_MBX_MSG_SET_PARAM_COUNT(9);
5424 HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr | REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
5425 #endif
5426 HALAUDIO_PRINT ("%d DSPBinBaseAddress = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPBinBaseAddress[u8Index]);
5427 HALAUDIO_PRINT ("%d DSPMadBaseBufferAdr = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index]);
5428 HALAUDIO_PRINT ("%d DSPMadMIUBank = %d\n", u8Index, g_AudioVars2->g_DSPMadMIUBank[u8Index]);
5429 }
5430
5431 ////////////////////////////////////////////////////////////////////////////////
5432 /// @brief \b Function \b Name: HAL_AUDIO_GetDspMadBaseAddr()
5433 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5434 /// @param <IN> \b u8Index :
5435 /// @param <OUT> \b NONE :
5436 /// @param <RET> \b MS_U32: return the MAD base address
5437 /// @param <GLOBAL> \b NONE :
5438 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)5439 MS_PHY HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)
5440 {
5441 HALAUDIO_CHECK_SHM_INIT;
5442
5443 if (u8Index == DSP_DEC) // MM case
5444 {
5445 return g_AudioVars2->g_DSPMadBaseBufferAdr[DSP_SE];
5446 }
5447 return g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5448 }
5449
5450 ////////////////////////////////////////////////////////////////////////////////
5451 /// @brief \b Function \b Name: HAL_AUDIO_GetDspBinBaseAddr()
5452 /// @brief \b Function \b Description: This function is used to get the Bin file base address.
5453 /// @param <IN> \b u8Index :
5454 /// @param <OUT> \b NONE :
5455 /// @param <RET> \b MS_U32: return the Bin file base address
5456 /// @param <GLOBAL> \b NONE :
5457 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)5458 MS_PHY HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)
5459 {
5460 HALAUDIO_CHECK_SHM_INIT;
5461
5462 return g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5463 }
5464
5465 ////////////////////////////////////////////////////////////////////////////////
5466 /// @brief \b Function \b Name: HAL_AUDIO_SetDspCodeType()
5467 /// @brief \b Function \b Description: This function is used to set the DSP code type.
5468 /// @param <IN> \b NONE :
5469 /// @param <OUT> \b NONE :
5470 /// @param <RET> \b MS_U8: DSP code type.
5471 /// @param <GLOBAL> \b NONE :
5472 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5473 void HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5474 {
5475 HALAUDIO_CHECK_SHM_INIT;
5476
5477 if(bFlag == FALSE)
5478 {
5479 DBG_AUDIO_ERROR(printf(" [Audio] DSP1 Load code fail !!! SetDspCodeType Fail !!! \r\n"));
5480 return;
5481 }
5482
5483 g_AudioVars2->g_DspCodeType = dspCodeType;
5484 }
5485
5486 ////////////////////////////////////////////////////////////////////////////////
5487 /// @brief \b Function \b Name: HAL_AUDIO_GetDspCodeType()
5488 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5489 /// @param <IN> \b NONE :
5490 /// @param <OUT> \b NONE :
5491 /// @param <RET> \b MS_U8: DSP code type.
5492 /// @param <GLOBAL> \b NONE :
5493 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspCodeType(void)5494 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDspCodeType(void)
5495 {
5496 HALAUDIO_CHECK_SHM_INIT;
5497
5498 return g_AudioVars2->g_DspCodeType;
5499 }
5500
5501
5502 ////////////////////////////////////////////////////////////////////////////////
5503 /// @brief \b Function \b Name: HAL_AUDIO_SetDsp2CodeType() @@Cathy
5504 /// @brief \b Function \b Description: This function is used to set the DSP2 code type.
5505 /// @param <IN> \b NONE :
5506 /// @param <OUT> \b NONE :
5507 /// @param <RET> \b MS_U8: DSP code type.
5508 /// @param <GLOBAL> \b NONE :
5509 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5510 void HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5511 {
5512 HALAUDIO_CHECK_SHM_INIT;
5513
5514 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5515 {
5516 return;
5517 }
5518
5519 if(bFlag == FALSE)
5520 {
5521 DBG_AUDIO_ERROR(printf(" [Audio] DSP2 Load code fail !!! SetDsp2CodeType Fail !!! \r\n"));
5522 return;
5523 }
5524 g_AudioVars2->g_Dsp2CodeType = dspCodeType;
5525 }
5526
5527 ////////////////////////////////////////////////////////////////////////////////
5528 /// @brief \b Function \b Name: HAL_AUDIO_GetDsp2CodeType() @@Cathy
5529 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5530 /// @param <IN> \b NONE :
5531 /// @param <OUT> \b NONE :
5532 /// @param <RET> \b MS_U8: DSP code type.
5533 /// @param <GLOBAL> \b NONE :
5534 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDsp2CodeType(void)5535 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDsp2CodeType(void)
5536 {
5537 HALAUDIO_CHECK_SHM_INIT;
5538
5539 return g_AudioVars2->g_Dsp2CodeType;
5540 }
5541
5542 ////////////////////////////////////////////////////////////////////////////////
5543 /// @brief \b Function \b Name: HAL_AUDIO_GetDSPalive()
5544 /// @brief \b Function \b Description: This function is used to check if DSP alive.
5545 /// @param <IN> \b NONE :
5546 /// @param <OUT> \b NONE :
5547 /// @param <RET> \b MS_U8: DSP alive status.
5548 /// @param <GLOBAL> \b NONE :
5549 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDSPalive(void)5550 MS_U8 HAL_AUDIO_GetDSPalive(void)
5551 {
5552 HALAUDIO_CHECK_SHM_INIT;
5553
5554 return g_AudioVars2->g_u8DspAliveFlag;
5555 }
5556
5557 ////////////////////////////////////////////////////////////////////////////////
5558 /// @brief \b Function \b Name: HAL_AUDIO_SetDSPalive()
5559 /// @brief \b Function \b Description: This function is used to set flag after DSP alive.
5560 /// @param <IN> \b NONE :
5561 /// @param <OUT> \b NONE :
5562 /// @param <RET> \b NONE :
5563 /// @param <GLOBAL> \b NONE :
5564 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDSPalive(MS_U8 alive)5565 void HAL_AUDIO_SetDSPalive(MS_U8 alive)
5566 {
5567 HALAUDIO_CHECK_SHM_INIT;
5568
5569 g_AudioVars2->g_u8DspAliveFlag = alive;
5570 }
5571 ////////////////////////////////////////////////////////////////////////////////
5572 /// @brief \b Function \b Name: HAL_AUDIO_SetAdvSndEffDspCodeType() @@Cathy
5573 /// @brief \b Function \b Description: This function is used to set the DSP AdvSndEff code type.
5574 /// @param <IN> \b NONE :
5575 /// @param <OUT> \b NONE :
5576 /// @param <RET> \b MS_U8: DSP code type.
5577 /// @param <GLOBAL> \b NONE :
5578 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5579 void HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5580 {
5581 HALAUDIO_CHECK_SHM_INIT;
5582
5583 if(bFlag == FALSE)
5584 {
5585 DBG_AUDIO_ERROR(printf(" [Audio] ADV_DSP Load code fail !!! SetAdvSndEffDspCodeType Fail !!! \r\n"));
5586 return;
5587 }
5588
5589 g_AudioVars2->g_AdvSndEffDspCodeType = dspCodeType;
5590 }
5591
5592 ////////////////////////////////////////////////////////////////////////////////
5593 /// @brief \b Function \b Name: HAL_AUDIO_GetAdvSndEffDspCodeType() @@Cathy
5594 /// @brief \b Function \b Description: This function is used to get the DSP AdvSndEff code type.
5595 /// @param <IN> \b NONE :
5596 /// @param <OUT> \b NONE :
5597 /// @param <RET> \b MS_U8: DSP code type.
5598 /// @param <GLOBAL> \b NONE :
5599 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetAdvSndEffDspCodeType(void)5600 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetAdvSndEffDspCodeType(void)
5601 {
5602 HALAUDIO_CHECK_SHM_INIT;
5603
5604 return g_AudioVars2->g_AdvSndEffDspCodeType;
5605 }
5606
5607 ////////////////////////////////////////////////////////////////////////////////
5608 /// @brief \b Function \b Name: HAL_AUDIO_BackupMailbox() @@Need_Modify
5609 /// @brief \b Function \b Description: This function is used to backup SIF mailbox.
5610 /// @param <IN> \b NONE :
5611 /// @param <OUT> \b NONE :
5612 /// @param <RET> \b NONE :
5613 /// @param <GLOBAL> \b NONE :
5614 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BackupMailbox(void)5615 void HAL_AUDIO_BackupMailbox(void)
5616 {
5617 int i;
5618
5619 for(i=0;i<12;i++)
5620 {
5621 SIF_MailBoxArray[i]=HAL_AUDIO_ReadByte(REG_SE_M2D_MAIL_BOX_BASE+i);
5622 }
5623 }
5624
5625 ////////////////////////////////////////////////////////////////////////////////
5626 /// @brief \b Function \b Name: HAL_AUDIO_RestoreMailbox() @@Need_Modify
5627 /// @brief \b Function \b Description: This function is used to restore SIF mailbox.
5628 /// @param <IN> \b NONE :
5629 /// @param <OUT> \b NONE :
5630 /// @param <RET> \b NONE :
5631 /// @param <GLOBAL> \b NONE :
5632 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RestoreMailbox(void)5633 void HAL_AUDIO_RestoreMailbox(void)
5634 {
5635 int i;
5636
5637 for(i=0;i<12;i++)
5638 {
5639 HAL_AUDIO_WriteByte((REG_SE_M2D_MAIL_BOX_BASE+i), SIF_MailBoxArray[i]);
5640 }
5641 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0xFF); // Toggle 2BCE to update N.F value
5642 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0x00);
5643 }
5644
5645
5646 ////////////////////////////////////////////////////////////////////////////////
5647 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5648 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5649 /// @param <IN> \b eType : sampleRate of PCM
5650 /// @param <OUT> \b NONE :
5651 /// @param <RET> \b NONE :
5652 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)5653 void HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)
5654 {
5655 MS_U32 audio_pcm_dmaRdr_bufSz = HW_DMA_RDR1_BUF_SIZE; //must be multiple of DMA_RDR_PCM_BUF_UNIT*2 = 0x2000
5656 MS_PHY audio_pcm_dmaRdr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
5657 MS_U16 synthrate, divisor;
5658 MS_U8 tmp1, tmp2, tmp3, tmp4;
5659 MS_U32 i;
5660
5661 /* init DMA writer address */
5662 dmaReader_writePtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5663 dmaReader_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5664 dmaReader_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base + audio_pcm_dmaRdr_bufSz);
5665
5666 /* New DMA Reader setting
5667 * Formula is :
5668 * Synthesizer Rate = 216MHz / Divisor(1, 2, 4 or 8) * 1024 / 256 / Sampling Rate(32Khz, 44.1KHz or 48KHz)
5669 */
5670 switch(sampleRate)
5671 {
5672 case SAMPLE_RATE_96000:
5673 divisor = 0;
5674 synthrate = 0x2328;
5675 break;
5676 case SAMPLE_RATE_44100:
5677 divisor = 0;
5678 synthrate = 0x4C87;
5679 break;
5680 case SAMPLE_RATE_32000:
5681 divisor = 0;
5682 synthrate = 0x6978;
5683 break;
5684 case SAMPLE_RATE_48000:
5685 divisor = 0;
5686 synthrate = 0x4650;
5687 break;
5688 case SAMPLE_RATE_22050:
5689 divisor = 1;
5690 synthrate = 0x4C87;
5691 break;
5692 case SAMPLE_RATE_16000:
5693 divisor = 1;
5694 synthrate = 0x6978;
5695 break;
5696 case SAMPLE_RATE_24000:
5697 divisor = 1;
5698 synthrate = 0x4650;
5699 break;
5700 case SAMPLE_RATE_11025:
5701 divisor = 2;
5702 synthrate = 0x4C87;
5703 break;
5704 case SAMPLE_RATE_8000:
5705 divisor = 2;
5706 synthrate = 0x6978;
5707 break;
5708 case SAMPLE_RATE_12000:
5709 divisor = 2;
5710 synthrate = 0x4650;
5711 break;
5712 default:
5713 divisor = 0;
5714 synthrate = 0x4650;
5715 break;
5716 }
5717
5718 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
5719 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04); //SEL_CLK_DMA_READER
5720 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F ); //CH8 sel to DMA Rdr
5721
5722 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //reset dma reader
5723
5724 HAL_AUDIO_WriteMaskByte(0x2B8E, 0xFF, ((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE) & 0xFF)); //DMA Reader Base Addr[7:0]
5725 HAL_AUDIO_WriteMaskReg(0x2B84, 0xFFFF,(((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>8) & 0xFFFF)); //DMA Reader Base Addr[23:8]
5726 HAL_AUDIO_WriteMaskByte(0x2B8F, 0x0F, (((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>24) & 0x0F)); //DMA Reader Base Addr[27:24]
5727
5728 HAL_AUDIO_WriteMaskReg(0x2B86, 0xFFFF, audio_pcm_dmaRdr_bufSz/BYTES_IN_MIU_LINE); //setting : DMA Reader Size
5729 HAL_AUDIO_WriteMaskReg(0x2B88, 0xFFFF, audio_pcm_dmaRdr_bufSz - 12); //setting : DMA Reader Overrun Thr
5730 HAL_AUDIO_WriteMaskReg(0x2B8A, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
5731
5732 /* synthersizer setting update */ //DMA reader
5733 HAL_AUDIO_WriteMaskByte(0x2CA4, 0x20, 0x20); //enable DMA synthesizer
5734 HAL_AUDIO_WriteMaskReg(0x2CB0, 0x6000, (divisor << 13)); //Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH
5735 HAL_AUDIO_WriteMaskReg(0x2C20, 0xFFFF, synthrate); //DMA synthesizer N.F.
5736
5737 /* Reset and Start DMA Reader */
5738 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x6402);
5739 AUDIO_DELAY1MS(1);
5740 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x2402);
5741
5742 /* Clear DMA Reader buffer */
5743 for ( i = 0; i < (HW_DMA_RDR1_BUF_SIZE/4); i++ )
5744 {
5745 tmp1 = 0;
5746 tmp2 = 0;
5747 tmp3 = 0;
5748 tmp4 = 0;
5749
5750 *dmaReader_writePtr++ = tmp1;
5751 *dmaReader_writePtr++ = tmp2;
5752 *dmaReader_writePtr++ = tmp3;
5753 *dmaReader_writePtr++ = tmp4;
5754 }
5755
5756 /* Reset Write Pointer */
5757 dmaReader_writePtr = dmaReader_bufStartAddress;
5758 }
5759
5760 ////////////////////////////////////////////////////////////////////////////////
5761 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5762 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5763 /// @param <IN> \b eType : sampleRate of PCM
5764 /// @param <OUT> \b NONE :
5765 /// @param <RET> \b NONE :
5766 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_AllInput_Init(void)5767 void HAL_AUDIO_DmaReader_AllInput_Init(void)
5768 {
5769 HAL_AUDIO_DmaReader_Init(SAMPLE_RATE_48000);
5770 return;
5771 }
5772
5773 ////////////////////////////////////////////////////////////////////////////////
5774 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_WritePCM()
5775 /// @brief \b Function \b Description: This routine is used to write PCM data into DMA reader Buffer
5776 /// @param <IN> \b eType : buffer bytes
5777 /// @param <OUT> \b NONE : TRUE or FALSE
5778 /// @param <RET> \b NONE :
5779 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_WritePCM(void * buffer,MS_U32 bytes)5780 MS_BOOL HAL_AUDIO_DmaReader_WritePCM(void* buffer, MS_U32 bytes)
5781 {
5782 MS_U8 *bufptr = (MS_U8 *)MS_PA2KSEG1((MS_VIRT)buffer);
5783 MS_U8 tmp1, tmp2, tmp3, tmp4, replay_flag=0;
5784 MS_U32 i, level_cnt;
5785
5786 // Mask LEVEL_CNT_MASK before read
5787 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5788 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5789 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5790
5791 if ( level_cnt <= 6 )
5792 {
5793 if ((HAL_AUDIO_ReadReg(0x2B80) & 0x0001) == 0x0001)
5794 replay_flag = 1;
5795
5796 /* reset dma reader */
5797 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //clear wr cntrs
5798
5799 /* Reset and Start DMA Reader */
5800 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x6402);
5801 AUDIO_DELAY1MS(1);
5802 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x2402);
5803
5804 /* Reset Write Pointer */
5805 dmaReader_writePtr = dmaReader_bufStartAddress;
5806
5807 printf("***** Audio DMAReader Buffer empty !! ***** \r\n");
5808 }
5809
5810 // Mask LEVEL_CNT_MASK before read
5811 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5812 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5813 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5814 if(level_cnt < (HW_DMA_RDR1_BUF_SIZE - bytes*2)/BYTES_IN_MIU_LINE)
5815 {
5816 for ( i = 0; i < (bytes/2); i++ )
5817 {
5818 tmp1 = 0;
5819 tmp2 = *bufptr++;
5820 tmp3 = *bufptr++;
5821 tmp4 = 0;
5822
5823 *dmaReader_writePtr++ = tmp1;
5824 *dmaReader_writePtr++ = tmp2;
5825 *dmaReader_writePtr++ = tmp3;
5826 *dmaReader_writePtr++ = tmp4;
5827
5828 if ( dmaReader_writePtr >= dmaReader_bufEndAddress )
5829 dmaReader_writePtr = dmaReader_bufStartAddress;
5830 }
5831 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, bytes*2/BYTES_IN_MIU_LINE);
5832 AUDIO_DELAY1US(5); // To prevent slow update of level_cnt
5833
5834 if (replay_flag == 1)
5835 {
5836 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
5837 AUDIO_DELAY1MS(1);
5838 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
5839 }
5840 return TRUE;
5841 }
5842 return FALSE;
5843 }
5844
5845 ////////////////////////////////////////////////////////////////////////////////
5846 /// @brief \b Function \b Name: HAL_AUDIO_SetEntertainmentMode()
5847 /// @brief \b Function \b Description: This routine is used to switch the DTV/KTV/GAME mode
5848 /// @param <IN> \b eMode :
5849 /// @param <RET> \b NONE :
5850 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)5851 void HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)
5852 {
5853 switch((int)eMode)
5854 {
5855 case AUDIO_ETMODE_DTV :
5856 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5857 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x00);
5858 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5859 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x00); // ADC0 gain 0dB
5860 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5861 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5862 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5863 break;
5864
5865 case AUDIO_ETMODE_KTV :
5866 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5867 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5868 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x80); // enable KTV function
5869 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x80); // ADC0 gain 6dB
5870 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5871 HAL_AUDIO_WriteMaskReg(REG_SNDR2_ADVSND_SEL, 0xFF00, 0x1E00); // Switch R2 to KTV mode
5872 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
5873 break;
5874
5875 case AUDIO_ETMODE_KTV2 : // Use I2S input ; not MicroPhone in
5876 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5877 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5878 HAL_AUDIO_WriteMaskByte(0x2D47 , 0xF0, 0xA0); // enable KTV mode; Skyworth (stone) model
5879 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5880 HAL_AUDIO_WriteMaskByte(0x2D5D , 0x80, 0x80); // Mute MIC volume (only mix MP3 & PCM DMA data)
5881 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5882 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5883 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
5884 break;
5885
5886 case AUDIO_ETMODE_GAME :
5887 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5888 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5889 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5890 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5891 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5892 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5893 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5894 break;
5895
5896 case AUDIO_ETMODE_VOIP_ON:
5897 //Voip will setup snd system to GAME MODE,
5898 //In GAME MODE, Voip used 0x2D46[7:0] to
5899 //upload Raw_Delay_SE to DRAM.
5900 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0xA1);
5901
5902 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5903 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xE0);
5904 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0xC4);
5905
5906 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5907 AUDIO_DELAY1MS(1);
5908 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5909 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5910
5911 #if 0
5912 //config SRC to 8KHz
5913 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xF0);//0xE0}, // Group A SRC rate
5914 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x03);//0x07},
5915 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0xF0);//0x50},
5916 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0xD2);//0x46},
5917 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5918 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x04);//0x08},
5919 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0xF0);//0x50},
5920 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0xD2);//0x46},
5921 //update SYNTH
5922 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5923 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5924 AUDIO_DELAY1MS(1);
5925 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5926 //reset GroupA SRC
5927 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5928 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5929 AUDIO_DELAY1MS(1);
5930 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5931 #endif
5932
5933 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_ON\r\n");
5934 break;
5935
5936 case AUDIO_ETMODE_VOIP_OFF:
5937 //disable upload Raw_Delay_SE to DRAM.
5938 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0x00);
5939
5940 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5941 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xD0);
5942 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0x20);
5943
5944 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5945 AUDIO_DELAY1MS(1);
5946 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5947 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5948
5949 #if 0
5950 //set SRC back to 48KHz
5951 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xE0); // Group A SRC rate
5952 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x07);
5953 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0x50);
5954 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0x46);
5955 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5956 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x08);
5957 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0x50);
5958 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0x46);
5959 //update SYNTH
5960 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5961 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5962 AUDIO_DELAY1MS(1);
5963 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5964 //reset GroupA SRC
5965 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5966 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5967 AUDIO_DELAY1MS(1);
5968 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5969 #endif
5970 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_OFF\r\n");
5971 break;
5972
5973 default :
5974 break;
5975 }
5976 }
5977
5978
5979 ////////////////////////////////////////////////////////////////////////////////
5980 /// @brief \b Function \b Name: HAL_AUDIO_SetSystem()
5981 /// @brief \b Function \b Description: This function will load
5982 /// different audio decoder to audio system.
5983 ///
5984 /// In Mstar audio system, we can support 1 or 2 decoders.
5985 /// One is for main DTV audio or Multimedia audio player.
5986 /// Another is for second audio decode (ex: used for Audio Description purpose)
5987 ///
5988 /// @param enDecSystem \b : (En_DVB_decSystemType) decoder type
5989 /// - parameter type "MSAPI_AUD_DVB_XXXX" is decoder type for main audio decoder
5990 /// - parameter type "MSAPI_AUD_DVB2_XXXX" is decoder type for second audio decoder
5991 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)5992 MS_BOOL HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)
5993 {
5994 //MS_BOOL pas2_sel = TRUE;
5995 MS_BOOL bRet = TRUE;
5996 En_DVB_decSystemType eDecSystemType = MSAPI_AUD_DVB_INVALID;
5997 AUDIO_DEC_ID eDecId = AU_DEC_ID1;
5998
5999 HALAUDIO_CHECK_SHM_INIT;
6000
6001 HAL_AUDIO_SetIsDtvFlag(TRUE);
6002 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, FALSE, 0);
6003
6004 // set decoder system
6005 switch (enDecSystem)
6006 {
6007 ////////////////////////////////////////////////
6008 // Audio Decoder 1
6009 ////////////////////////////////////////////////
6010 case MSAPI_AUD_DVB_MPEG:
6011 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
6012 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
6013 eDecId = AU_DEC_ID1;
6014 eDecSystemType = MSAPI_AUD_DVB_MPEG;
6015 break;
6016
6017 case MSAPI_AUD_DVB_AC3:
6018 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6019 AUDIO_DELAY1MS(1);
6020 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6021 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6022 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3, TRUE);
6023 eDecId = AU_DEC_ID1;
6024 eDecSystemType = MSAPI_AUD_DVB_AC3;
6025 break;
6026
6027 case MSAPI_AUD_DVB_AC3P:
6028 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6029 AUDIO_DELAY1MS(1);
6030 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6031 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6032 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
6033 eDecId = AU_DEC_ID1;
6034 eDecSystemType = MSAPI_AUD_DVB_AC3P;
6035 break;
6036
6037 case MSAPI_AUD_DVB_MP3:
6038 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
6039 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MP3, TRUE);
6040 eDecId = AU_DEC_ID1;
6041 eDecSystemType = MSAPI_AUD_DVB_MP3;
6042 break;
6043
6044 case MSAPI_AUD_DVB_AAC:
6045 case MSAPI_AUD_DVB_MS10_DDT:
6046 if (g_AudioVars2->DolbyAACFlag == 1)
6047 {
6048 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_aac);
6049 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
6050 }
6051 else
6052 {
6053 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_gaac);
6054 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
6055 }
6056 eDecId = AU_DEC_ID1;
6057 eDecSystemType = MSAPI_AUD_DVB_AAC;
6058 break;
6059
6060 case MSAPI_AUD_DVB_XPCM:
6061 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_xpcm);
6062 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
6063 eDecId = AU_DEC_ID1;
6064 eDecSystemType = MSAPI_AUD_DVB_XPCM;
6065 break;
6066
6067 case MSAPI_AUD_DVB_RA8LBR:
6068 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ra8);
6069 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
6070 eDecId = AU_DEC_ID1;
6071 eDecSystemType = MSAPI_AUD_DVB_RA8LBR;
6072 break;
6073
6074 case MSAPI_AUD_DVB_WMA:
6075 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
6076 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
6077 eDecId = AU_DEC_ID1;
6078 eDecSystemType = MSAPI_AUD_DVB_WMA;
6079 break;
6080
6081 case MSAPI_AUD_DVB_DTS:
6082 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6083 AUDIO_DELAY1MS(1);
6084 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6085 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
6086 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
6087 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
6088 eDecId = AU_DEC_ID1;
6089 eDecSystemType = MSAPI_AUD_DVB_DTS;
6090 break;
6091
6092 case MSAPI_AUD_DVB_DTSLBR:
6093 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
6094 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTSLBR, TRUE);
6095 eDecId = AU_DEC_ID1;
6096 eDecSystemType = MSAPI_AUD_DVB_DTSLBR;
6097 break;
6098
6099 case MSAPI_AUD_DVB_MS10_DDC:
6100 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6101 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDC, TRUE);
6102 eDecId = AU_DEC_ID1;
6103 eDecSystemType = MSAPI_AUD_DVB_AC3P;
6104 break;
6105
6106 case MSAPI_AUD_DVB_WMA_PRO:
6107 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
6108 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
6109 eDecId = AU_DEC_ID1;
6110 eDecSystemType = MSAPI_AUD_DVB_WMA_PRO;
6111 break;
6112
6113 case MSAPI_AUD_DVB_FLAC:
6114 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_flac);
6115 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
6116 eDecId = AU_DEC_ID1;
6117 eDecSystemType = MSAPI_AUD_DVB_FLAC;
6118 break;
6119
6120 case MSAPI_AUD_DVB_VORBIS:
6121 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_vorbis);
6122 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
6123 eDecId = AU_DEC_ID1;
6124 eDecSystemType = MSAPI_AUD_DVB_VORBIS;
6125 break;
6126
6127 case MSAPI_AUD_DVB_AMR_NB:
6128 eDecId = AU_DEC_ID1;
6129 eDecSystemType = MSAPI_AUD_DVB_AMR_NB;
6130 break;
6131
6132 case MSAPI_AUD_DVB_AMR_WB:
6133 eDecId = AU_DEC_ID1;
6134 eDecSystemType = MSAPI_AUD_DVB_AMR_WB;
6135 break;
6136
6137 case MSAPI_AUD_DVB_DRA:
6138 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dra);
6139 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
6140 eDecId = AU_DEC_ID1;
6141 eDecSystemType = MSAPI_AUD_DVB_DRA;
6142 break;
6143
6144
6145 ////////////////////////////////////////////////
6146 // Audio Decoder 2
6147 ////////////////////////////////////////////////
6148 case MSAPI_AUD_DVB2_MPEG:
6149 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
6150 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
6151 eDecId = AU_DEC_ID3;
6152 eDecSystemType = MSAPI_AUD_DVB_MPEG;
6153 break;
6154
6155 case MSAPI_AUD_DVB2_AC3:
6156 case MSAPI_AUD_DVB2_AC3P:
6157 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
6158 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3, TRUE);
6159 eDecId = AU_DEC_ID3;
6160 eDecSystemType = MSAPI_AUD_DVB_AC3;
6161 break;
6162
6163 case MSAPI_AUD_DVB2_MP3:
6164 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
6165 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MP3, TRUE);
6166 eDecId = AU_DEC_ID3;
6167 eDecSystemType = MSAPI_AUD_DVB_MP3;
6168 break;
6169
6170 case MSAPI_AUD_DVB2_AAC:
6171 case MSAPI_AUD_DVB2_GAAC:
6172 if (g_AudioVars2->DolbyAACFlag == 1)
6173 {
6174 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_aac);
6175 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
6176 }
6177 else
6178 {
6179 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_gaac);
6180 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
6181 }
6182 eDecId = AU_DEC_ID3;
6183 eDecSystemType = MSAPI_AUD_DVB_AAC;
6184 break;
6185
6186 case MSAPI_AUD_DVB2_DTS:
6187 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dts);
6188 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
6189 eDecId = AU_DEC_ID3;
6190 eDecSystemType = MSAPI_AUD_DVB_DTS;
6191 break;
6192
6193 case MSAPI_AUD_DVB2_XPCM:
6194 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_xpcm);
6195 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
6196 eDecId = AU_DEC_ID3;
6197 eDecSystemType = MSAPI_AUD_DVB_XPCM;
6198 break;
6199
6200 default:
6201 HAL_AUDIO_SetIsDtvFlag(FALSE);
6202 bRet = FALSE;
6203 break;
6204 }
6205
6206 if (bRet == TRUE)
6207 {
6208 g_AudioVars2->AudioDecStatus[eDecId].eAudFormat = eDecSystemType;
6209 }
6210
6211 return bRet;
6212 }
6213
6214 ////////////////////////////////////////////////////////////////////////////////
6215 /// @brief \b Function \b Name: HAL_AUDIO_GetDecSysSupportStatus()
6216 /// @brief \b Function \b Description: This function will report Audio Decoder support feature status when giving DecSystem type
6217 /// @param <IN> \b enDecSystem : Decoder type
6218 /// @param <RET> \b BOOL : True or False
6219 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)6220 MS_BOOL HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)
6221 {
6222 MS_BOOL SetDecSys_RtnStatus = FALSE;
6223 switch (enDecSystem)
6224 {
6225 ////////////////////////////////////////////////
6226 // Audio Decoder 1
6227 ////////////////////////////////////////////////
6228 case MSAPI_AUD_DVB_MPEG:
6229 case MSAPI_AUD_DVB_AC3:
6230 case MSAPI_AUD_DVB_AC3P:
6231 case MSAPI_AUD_DVB_MP3:
6232 case MSAPI_AUD_DVB_AAC:
6233 SetDecSys_RtnStatus = TRUE;
6234 break;
6235
6236 case MSAPI_AUD_DVB_MS10_DDT:
6237 case MSAPI_AUD_DVB_MS10_DDC:
6238 SetDecSys_RtnStatus = TRUE;
6239 break;
6240
6241 case MSAPI_AUD_DVB_XPCM:
6242 case MSAPI_AUD_DVB_RA8LBR:
6243 SetDecSys_RtnStatus = TRUE;
6244 break;
6245
6246 case MSAPI_AUD_DVB_WMA:
6247 case MSAPI_AUD_DVB_WMA_PRO:
6248 SetDecSys_RtnStatus = TRUE;
6249 break;
6250
6251 case MSAPI_AUD_DVB_DTS:
6252 SetDecSys_RtnStatus = TRUE;
6253 break;
6254
6255 case MSAPI_AUD_DVB_FLAC:
6256 SetDecSys_RtnStatus = TRUE;
6257 break;
6258
6259 case MSAPI_AUD_DVB_VORBIS:
6260 SetDecSys_RtnStatus = TRUE;
6261 break;
6262
6263 case MSAPI_AUD_DVB_AMR_NB:
6264 SetDecSys_RtnStatus = FALSE;
6265 break;
6266
6267 case MSAPI_AUD_DVB_AMR_WB:
6268 SetDecSys_RtnStatus = FALSE;
6269 break;
6270
6271 ////////////////////////////////////////////////
6272 // Audio Decoder 2
6273 ////////////////////////////////////////////////
6274 case MSAPI_AUD_DVB2_MPEG:
6275 case MSAPI_AUD_DVB2_MP3:
6276 SetDecSys_RtnStatus = TRUE;
6277 break;
6278
6279 case MSAPI_AUD_DVB2_AC3:
6280 case MSAPI_AUD_DVB2_AC3P:
6281 SetDecSys_RtnStatus = TRUE;
6282 break;
6283
6284 case MSAPI_AUD_DVB2_AAC:
6285 SetDecSys_RtnStatus = TRUE;
6286 break;
6287
6288 case MSAPI_AUD_DVB2_DDE:
6289 SetDecSys_RtnStatus = FALSE;
6290 break;
6291
6292 case MSAPI_AUD_DVB2_DTSE:
6293 SetDecSys_RtnStatus = FALSE;
6294 break;
6295
6296 case MSAPI_AUD_DVB2_XPCM:
6297 SetDecSys_RtnStatus = TRUE;
6298 break;
6299
6300 case MSAPI_AUD_DVB2_KTV:
6301 SetDecSys_RtnStatus = TRUE;
6302 break;
6303
6304 case MSAPI_AUD_DVB_TONE:
6305 case MSAPI_AUD_DVB_NONE:
6306 case MSAPI_AUD_DVB2_NONE:
6307 default:
6308 SetDecSys_RtnStatus = FALSE;
6309 break;
6310 }
6311 return(SetDecSys_RtnStatus);
6312 }
6313
6314 ////////////////////////////////////////////////////////////////////////////////
6315 /// @brief \b Function \b Name: HAL_AUDIO_AlgReloadCode()
6316 /// @brief \b Function \b Description: This routine is used to reload DSP code
6317 /// @param u8Type \b :
6318 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
6319 /// FALSE--DEC-DSP reload code fail
6320 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)6321 MS_BOOL HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
6322 {
6323 int time_out;
6324 MS_BOOL bRet = FALSE;
6325
6326 // Enter MCU/DSP hand-shake
6327 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6328 {
6329 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
6330 }
6331 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6332 {
6333 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV2_END/0x100);
6334 }
6335 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6336 {
6337 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
6338 }
6339 else
6340 {
6341 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
6342 }
6343 // PIO[8] interrupt
6344 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
6345 HAL_MAD_TriggerPIO8();
6346
6347 //Wait Dsp Start reload Ack
6348 time_out = 0;
6349 while(time_out++<1000)
6350 {
6351 if(HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
6352 break;
6353 AUDIO_DELAY1MS(2);
6354 }
6355 if(time_out>=1000)
6356 {
6357 DBG_AUDIO_ERROR(" DSP Re-active1: %d\r\n",time_out);
6358 return FALSE;
6359 }
6360
6361 // Change to IDMA Port
6362 HAL_MAD_SetDspIDMA();
6363
6364 // Start to reload DSP code
6365 bRet = HAL_AUDSP_DspLoadCode(dspCodeType);
6366 if ( bRet == FALSE )
6367 {
6368 DBG_AUDIO_ERROR(" DSP reload fail !!\r\n");
6369 // PIO[8] interrupt
6370 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
6371 HAL_MAD_TriggerPIO8();
6372 HAL_MAD_SetMcuCmd(0x00); // In T3 T8, clear 0x2D9C after reload finish
6373 return FALSE;
6374 }
6375
6376 // Enter MCU/DSP hand-shake
6377 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6378 {
6379 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
6380 }
6381 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6382 {
6383 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV2_END/0x100);
6384 }
6385 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6386 {
6387 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
6388 }
6389 else
6390 {
6391 HAL_MAD_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV1_END/0x100);
6392 }
6393
6394 // PIO[8] interrupt
6395 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
6396 HAL_MAD_TriggerPIO8();
6397
6398 // Wait Dsp End Reload Ack
6399 time_out = 0;
6400 while(time_out++<1500)
6401 {
6402 if(HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
6403 {
6404 break;
6405 }
6406 AUDIO_DELAY1MS(2);
6407 }
6408
6409 if(time_out>=1500)
6410 {
6411 DBG_AUDIO_ERROR(" DSP Re-active2: %d\r\n",time_out);
6412 return FALSE;
6413 }
6414
6415 HAL_MAD_SetMcuCmd(0x00); // In T3 T8, clear 0x2D9C after reload finish
6416
6417 return bRet;
6418 }
6419 #if 0
6420 {
6421 MS_U16 time_out;
6422 MS_BOOL ret_status = FALSE;
6423
6424 HAL_MAD2_SetDspIDMA();
6425 // Enter MCU/DSP hand-shake
6426 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6427 {
6428 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
6429 }
6430 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6431 {
6432 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG/0x100);
6433 }
6434 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6435 {
6436 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_BEG/0x100);
6437 }
6438 else
6439 {
6440 //No Decoder in DSP
6441 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Warning! un-support DSP version decoder. \r\n", __FUNCTION__);
6442 //HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_BEG/0x100);
6443 }
6444
6445 // PIO[8] interrupt
6446 HAL_MAD2_TriggerPIO8();
6447
6448 //Wait Dsp Start reload Ack
6449 time_out = 0;
6450 while (time_out++<2000)
6451 {
6452 if(HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
6453 break;
6454 AUDIO_DELAY1MS(1);
6455 }
6456 if (time_out>=2000)
6457 {
6458 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " DSP Reload timeOut1: %d\r\n", time_out);
6459 return FALSE;
6460 }
6461
6462 // Change to IDMA Port
6463 HAL_MAD2_SetDspIDMA();
6464
6465 // Start to Reload DSP code
6466 ret_status = HAL_AUDSP_DspLoadCode(dspCodeType);
6467 HAL_AUDIO_SetDsp2CodeType(dspCodeType, ret_status);
6468
6469 // Enter MCU/DSP hand-shake
6470 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6471 {
6472 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_END/0x100);
6473 }
6474 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6475 {
6476 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END/0x100);
6477 }
6478 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6479 {
6480 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_END/0x100);
6481 }
6482 else
6483 {
6484 //No Decoder in DSP
6485 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Warning! un-support DSP version decoder. \r\n", __FUNCTION__);
6486 //HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_END/0x100);
6487 }
6488
6489 HAL_MAD2_TriggerPIO8();
6490
6491 // Wait Dsp End Reload Ack
6492 time_out = 0;
6493 while (time_out++<3000)
6494 {
6495 if (HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
6496 break;
6497 AUDIO_DELAY1MS(1);
6498 }
6499
6500 if (time_out>=3000)
6501 {
6502 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " DSP Reload timeOut2: %d\r\n", time_out);
6503 return FALSE;
6504 }
6505
6506 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "HAL_AUDIO_SeReloadCode finish\r\n");
6507
6508 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
6509
6510 return TRUE;
6511
6512 }
6513 #endif
6514 ////////////////////////////////////////////////////////////////////////////////
6515 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Check()
6516 /// @brief \b Function \b Description: Check if ALSA Interface is supported
6517 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
6518 /// @param <OUT> \b MS_BOOL : return TRUE if it's supported, else return FALSE
6519 /// @param <RET> \b NONE :
6520 /// @param <GLOBAL> \b NONE :
6521 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Check(void)6522 MS_BOOL HAL_AUDIO_ALSA_Check(void)
6523 {
6524 return TRUE;
6525 }
6526
6527 ////////////////////////////////////////////////////////////////////////////////
6528 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Enable()
6529 /// @brief \b Function \b Description: Enable/ Disable the path of ALSA
6530 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
6531 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
6532 /// @param <RET> \b NONE :
6533 /// @param <GLOBAL> \b NONE :
6534 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)6535 MS_BOOL HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)
6536 {
6537 if (bEnable == TRUE)
6538 {
6539 /* Set as GAME mode */
6540 HAL_AUDIO_SetInputPath(AUDIO_DSP3_DVB_INPUT , AUDIO_PATH_5);
6541 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
6542 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
6543 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
6544 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
6545
6546 return TRUE;
6547 }
6548 else
6549 {
6550 /* Do nothing for the moment */
6551 return FALSE;
6552 }
6553 }
6554
6555 ////////////////////////////////////////////////////////////////////////////////
6556 /// @brief \b Function \b Name: HAL_AUDIO_Alg2ReloadCode()
6557 /// @brief \b Function \b Description: This routine is used to reload the algorithm in se-dsp .
6558 /// @param u8Type \b : information of algorithm code
6559 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
6560 /// FALSE--DEC-DSP reload code fail
6561 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)6562 MS_BOOL HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
6563 {
6564 return TRUE;
6565 }
6566
6567 ////////////////////////////////////////////////////////////////////////////////
6568 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeDoneFlag() @@Cathy
6569 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
6570 /// @param <IN> \b NONE :
6571 /// @param <OUT> \b NONE :
6572 /// @param <RET> \b NONE :
6573 /// @param <GLOBAL> \b NONE :
6574 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeDoneTag(void)6575 MS_U16 HAL_AUDIO_GetUniDecodeDoneTag(void)
6576 {
6577 MS_U16 temp1, temp2, i;
6578
6579 for (i = 0; i < 100; i++)
6580 {
6581 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6582 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6583
6584 if (temp1 == temp2)
6585 {
6586 return (temp1);
6587 }
6588 }
6589
6590 return 0;
6591 }
6592
6593 ////////////////////////////////////////////////////////////////////////////////
6594 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeFrameCnt()
6595 /// @brief \b Function \b Description: This function is used to get the Decoder decoded frame count
6596 /// @param <IN> \b NONE:
6597 /// @param <OUT> \b NONE:
6598 /// @param <RET> \b NONE:
6599 /// @param <GLOBAL> \b NONE:
6600 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)6601 MS_U16 HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)
6602 {
6603 MS_U16 temp1, temp2, i;
6604 Audio_id r2AudioID = ADEC1;
6605
6606
6607 if (eDSPId == AU_DEC_ID3)
6608 {
6609 r2AudioID = ADEC2;
6610 }
6611
6612 for ( i = 0; i < 100; i++ )
6613 {
6614 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6615 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6616
6617 if ( temp1 == temp2 )
6618 {
6619 return (temp1);
6620 }
6621 }
6622
6623 return 0;
6624 }
6625
6626 //******************************************************************************
6627 // [Function Name]:
6628 // HAL_AUDIO_PTS_info
6629 // [Description]:
6630 // get PTS and OS time or set to reset these reference
6631 // [Arguments]:
6632 //
6633 //*******************************************************************************
HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info)6634 void HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info )
6635 {
6636 AUDIO_PTS_INFO PTS_info;
6637
6638 memcpy((void *)&PTS_info,(void *)access_PTS_info,sizeof(AUDIO_PTS_INFO));
6639
6640 // printf("HAL_AUDIO_PTS_info((0x%x, %d, %lld))\n",(unsigned int)access_PTS_info,(int)PTS_info.os_Time,PTS_info.curPTS);
6641 if(PTS_info.set2Clr) //setting value
6642 {
6643 curr_OS_Time = PTS_info.os_Time;
6644 curr_PTS = PTS_info.curPTS;
6645 }
6646 else // get PTS information
6647 {
6648
6649 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6650
6651 PTS_info.set2Clr = 0 ;
6652 PTS_info.os_Time = curr_OS_Time;
6653 PTS_info.curPTS = curr_PTS;
6654
6655 memcpy((void *)access_PTS_info,(void *)&PTS_info,sizeof(AUDIO_PTS_INFO));
6656
6657 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6658 }
6659 }
6660
HAL_AUDIO_DmaWriter_Init(void)6661 void HAL_AUDIO_DmaWriter_Init(void)
6662 {
6663 return;
6664 }
6665
6666 ////////////////////////////////////////////////////////////////////////////////
6667 /// @brief \b Function \b Name: HAL_AUDIO_RebootDecDSP()
6668 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RebootDecDSP(void)6669 void HAL_AUDIO_RebootDecDSP(void)
6670 {
6671 MS_U8 u8DspCodeType;
6672 AU_DVB_DECCMD deccmd_status;
6673 AUD_ERRMSG("\n*MAD Auto-Recovery DEC-R2* \n");
6674
6675 HALAUDIO_CHECK_SHM_INIT;
6676
6677 g_AudioVars2->g_u8AudioCrashFlag = TRUE;
6678
6679 u8DspCodeType=(MS_U8)(HAL_AUDIO_GetDspCodeType());
6680 deccmd_status = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
6681
6682 //if ((u8DspCodeType & 0xF0) != 0x10)
6683 {
6684 HAL_AUDIO_BackupMailbox();
6685 }
6686 // Reset MAD module
6687 HAL_MAD_RSTMAD_DisEn_MIUREQ();
6688 AUDIO_DELAY1MS(2);
6689
6690 //if((u8DspCodeType & 0xF0) != 0x10 )
6691 {
6692 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, FALSE, 0); // Audio SIF channel enable setting -> disable
6693 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 0, 0);
6694
6695 AUDIO_DELAY1MS(2);
6696 }
6697 AUD_DBGMSG("*** Load code and reset DEC-R2 \n");
6698 HAL_MAD2_SetMemInfo();
6699 HAL_AUDIO_ResetDSP();
6700 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
6701 HAL_AUDSP_DECR2LoadCode();
6702 HAL_MAD_LoadCode((AUDIO_DSP_CODE_TYPE)u8DspCodeType);
6703
6704 HAL_MAD_SetDecCmd(deccmd_status);
6705 //if((u8DspCodeType & 0xF0) != 0x10 )
6706 {
6707 AUDIO_DELAY1MS(50);
6708 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 1, 0);
6709 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0); // Audio SIF channel enable setting -> enable
6710 HAL_AUDIO_RestoreMailbox();
6711 }
6712 }
6713
6714 ////////////////////////////////////////////////////////////////////////////////
6715 /// @brief \b Function \b Name: HAL_AUDIO_DspReboot()
6716 /// @brief \b Function \b Description: This routine is used to do dsp reboot and some specific setting
6717 /// @param <IN> \b eType : param
6718 /// @param <RET> \b NONE :
6719 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspReboot(MS_U8 alive)6720 void HAL_AUDIO_DspReboot(MS_U8 alive)
6721 {
6722 UNUSED(alive);
6723 }
6724
6725
6726 ////////////////////////////////////////////////////////////////////////////////
6727 /// @brief \b Function \b Name: HAL_AUDIO_ReadDspCounter()
6728 /// @brief \b Function \b Description: Read the DSP running counter
6729 /// @param CounterType \b :
6730 /// - DSP_DEC_MAIN_COUNTER ==> Decoder DSP Main loop counter
6731 /// - DSP_DEC_TIMER_COUNTER ==> Decoder Timer counter
6732 /// - DSP_SE_MAIN_COUNTER ==> SE DSP Main loop counter
6733 /// - DSP_SE_TIMER_COUNTER ==> SE Timer counter
6734 /// - DSP_SE_ISR_COUNTER ==> SE Interrupt ISR counter
6735 /// @return MS_U8 \b : Running counter value
6736 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)6737 MS_U8 HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)
6738 {
6739 MS_U8 u8CounterValue=0;
6740
6741 switch(CounterType)
6742 {
6743 case DSP_DEC_MAIN_COUNTER:
6744 break;
6745
6746 case DSP_DEC_TIMER_COUNTER:
6747 break;
6748
6749 case DSP_SE_MAIN_COUNTER:
6750 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_COUNTER);
6751 break;
6752
6753 case DSP_SE_TIMER_COUNTER:
6754 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_TIMER_COUNTER);
6755 break;
6756
6757 case DSP_SE_ISR_COUNTER:
6758 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_ISR_COUNTER);
6759 break;
6760
6761 case DEC_R2_MAIN_COUNTER:
6762 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_MAIN_COUNTER);
6763 break;
6764
6765 case DEC_R2_TIMER_COUNTER:
6766 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_TIMER_COUNTER);
6767 break;
6768
6769 case SND_R2_MAIN_COUNTER:
6770 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_MAIN_COUNTER);
6771 break;
6772
6773 case SND_R2_TIMER_COUNTER:
6774 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_TIMER_COUNTER);
6775 break;
6776
6777 default:
6778 break;
6779 }
6780 return u8CounterValue;
6781 }
6782
6783
6784 ////////////////////////////////////////////////////////////////////////////////
6785 /// @brief \b Function \b Name: HAL_AuProcessPowerDown_Wait()
6786 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
6787 /// @param bEnable \b : TRUE --Not wait,
6788 /// FALSE--wait
6789 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)6790 void HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)
6791 {
6792 UNUSED(bEnable);
6793 }
6794
6795 ////////////////////////////////////////////////////////////////////////////////
6796 /// @brief \b Function \b Name: HAL_AUDIO_SendIntrupt()
6797 /// @brief \b Function \b Description: send a PIO8 interrupt to DSP
6798 /// @param bDspType \b :
6799 /// @param u8Cmd \b :
6800 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)6801 void HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)
6802 {
6803 if (bDspType == DSP_DEC)
6804 {
6805 HAL_MAD_SetPIOCmd(u8Cmd);
6806 HAL_MAD_TriggerPIO8();
6807 }
6808 else
6809 {
6810 HAL_MAD2_SetPIOCmd(u8Cmd);
6811 HAL_MAD2_TriggerPIO8();
6812 }
6813 }
6814
6815 ////////////////////////////////////////////////////////////////////////////////
6816 /// @brief \b Function \b Name: HAL_AUDIO_SeSystemLoadCode()
6817 /// @brief \b Function \b Description: This routine is used to load DSP code for SE-DSP .
6818 /// @return MS_BOOL \b : TRUE --DEC-DSP load code okay,
6819 /// FALSE--DEC-DSP load code fail
6820 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeSystemLoadCode(void)6821 MS_BOOL HAL_AUDIO_SeSystemLoadCode(void)
6822 {
6823 MS_U16 time_out = 0;
6824 //MS_U32 DEC_R2_ADDR = HAL_AUDIO_GetDspMadBaseAddr(DSP_ADV); // Get ADEC R2 Start address
6825 //MS_U32 SND_R2_ADDR = DEC_R2_ADDR + ADEC__R2_DDR_SIZE; // Get SND-R2 Start address
6826
6827 HAL_MAD2_SetDspIDMA();
6828
6829 AUD_DBGMSG("MDrv_AUDIO_SeSystemLoadCode() \r\n");
6830
6831 HAL_AUDSP_DspLoadCode(AU_SE_SYSTEM);
6832
6833 #if 0 //secure boot (Reserved)
6834 //Wait R2 boot code init finished Ack
6835 #ifndef CONFIG_MBOOT
6836 while(time_out++<100)
6837 {
6838 if((HAL_AUR2_ReadReg(REG_DECR2_BOOTCODE_DONE_ACK) == 0x1234)&&(HAL_AUR2_ReadReg(REG_SNDR2_BOOTCODE_DONE_ACK) == 0x1234))
6839 break;
6840 AUDIO_DELAY1MS(2);
6841 }
6842 #else
6843 while(time_out++<100)
6844 {
6845 if(HAL_AUR2_ReadReg(REG_DECR2_BOOTCODE_DONE_ACK) == 0x1234)
6846 break;
6847 AUDIO_DELAY1MS(2);
6848 }
6849 #endif
6850
6851 if(time_out>=100)
6852 {
6853 AUD_ERRMSG("audio R2 boot code timeout\n");
6854 }
6855 else
6856 {
6857 AUD_DBGMSG("audio R2 boot code success\n");
6858 }
6859
6860 HAL_SND_R2_EnableR2(FALSE); // stop SND-R2 after load R2 boot code
6861 HAL_DEC_R2_EnableR2(FALSE); // stop DEC-R2 after load R2 boot code
6862 HAL_AUR2_WriteMaskReg(REG_SDR_SWITCH_CTRL, 0x0001, 0x0001); //use SDR2 address [1]:0x1630 [0];0x1129
6863
6864 HAL_AUR2_WriteReg(REG_DECR2_ICMEM2_BASE_LO, (MS_U16)(DEC_R2_ADDR & 0xFFFF));
6865 HAL_AUR2_WriteReg(REG_DECR2_ICMEM2_BASE_HI, (MS_U16)((DEC_R2_ADDR >> 16) & 0xFFFF));
6866 HAL_AUR2_WriteReg(REG_DECR2_DCMEM_BASE_LO, (MS_U16)(DEC_R2_ADDR & 0xFFFF));
6867 HAL_AUR2_WriteReg(REG_DECR2_DCMEM_BASE_HI, (MS_U16)((DEC_R2_ADDR >> 16) & 0xFFFF));
6868 #ifndef CONFIG_MBOOT
6869 HAL_AUR2_WriteMaskReg(REG_SDR_SWITCH_CTRL, 0x0002, 0x0002); //use SDR2 address [1]:0x1630 [0];0x1129
6870 HAL_AUR2_WriteReg(REG_SNDR2_ICMEM2_BASE_LO, (MS_U16)(SND_R2_ADDR & 0xFFFF));
6871 HAL_AUR2_WriteReg(REG_SNDR2_ICMEM2_BASE_HI, (MS_U16)((SND_R2_ADDR >> 16) & 0xFFFF));
6872 HAL_AUR2_WriteReg(REG_SNDR2_DCMEM_BASE_LO, (MS_U16)(SND_R2_ADDR & 0xFFFF));
6873 HAL_AUR2_WriteReg(REG_SNDR2_DCMEM_BASE_HI, (MS_U16)((SND_R2_ADDR >> 16) & 0xFFFF));
6874 HAL_SND_R2_EnableR2(TRUE); // start SND-R2 after load R2 code
6875 #endif
6876 HAL_DEC_R2_init_SHM_param();
6877 HAL_DEC_R2_EnableR2(TRUE); // start DEC-R2 after load R2 code
6878 #endif
6879
6880 time_out = 0;
6881 //Wait Dsp/R2 init finished Ack
6882 #ifndef CONFIG_MBOOT
6883 while(time_out++<100)
6884 {
6885 if(HAL_AUR2_ReadByte(REG_DECR2_ACK1) == 0xE3)
6886 break;
6887 AUDIO_DELAY1MS(2);
6888 }
6889 #else
6890 while(time_out++<100)
6891 {
6892 if(HAL_AUR2_ReadByte(REG_DECR2_ACK1) == 0xE3)
6893 break;
6894 AUDIO_DELAY1MS(2);
6895 }
6896 #endif
6897
6898 if(time_out>=100)
6899 {
6900 AUD_ERRMSG("DSP2 or R2 Re-Active\n");
6901 }
6902 else
6903 {
6904 AUD_DBGMSG("audio DSP_SE LoadCode success..\n");
6905 }
6906
6907 //inform DSP to start to run
6908 HAL_MAD2_SetMcuCmd(0xF3);
6909
6910 return TRUE;
6911 }
6912
6913 ////////////////////////////////////////////////////////////////////////////////
6914 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6915 ////////////////////////////////////////////////////////////////////////////////
6916 ////////////////////////////////////////////////////////////////////////////////
6917 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6918 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecoderLoadCode(void)6919 MS_BOOL HAL_AUDIO_DecoderLoadCode(void)
6920 {
6921 return TRUE;
6922 }
6923
6924 ////////////////////////////////////////////////////////////////////////////////
6925 /// @brief \b Function \b Name: HAL_AUDIO_init()
6926 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Init(MS_BOOL Initype)6927 MS_BOOL HAL_AUDIO_Init(MS_BOOL Initype)
6928 {
6929 return Initype;
6930 }
6931
6932 ////////////////////////////////////////////////////////////////////////////////
6933 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_TX_SetMode()
6934 /// @brief \b Function \b Description: This routine is used to set HDMI output mode
6935 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType,AUDIO_SOURCE_INFO_TYPE eSource)6936 void HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType, AUDIO_SOURCE_INFO_TYPE eSource)
6937 {
6938 HDMI_TX_OUTPUT_TYPE outType_tmp = outType;
6939 AUDIO_DSP_CODE_TYPE Dsp1CodeType = MSAPI_AUD_DVB_INVALID;
6940 AUDIO_DSP_CODE_TYPE Dsp2CodeType = MSAPI_AUD_DVB_INVALID;
6941 AUDIO_DSP_CODE_TYPE MainDspCodeType = MSAPI_AUD_DVB_INVALID;
6942 MS_U8 u8NonPcmPath = ADEC1; /* R2: ADEC1, ADEC2 */
6943
6944 HALAUDIO_CHECK_SHM_INIT;
6945
6946 DBG_AUDIO(printf("=== HAL_AUDIO_HDMI_SetMode: %d, src:%d ===\n", outType, eSource));
6947
6948 if ( g_AudioVars2 != NULL )
6949 {
6950 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
6951 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
6952 }
6953 else
6954 {
6955 HALAUDIO_ERROR("%s: g_AudioVars2 should not be NULL !!\r\n", __FUNCTION__);
6956 return;
6957 }
6958
6959 switch (eSource)
6960 {
6961 case E_AUDIO_INFO_DTV_IN:
6962 {
6963 MainDspCodeType = Dsp1CodeType;
6964 u8NonPcmPath = ADEC1; /* R2 */
6965
6966 if((MainDspCodeType == AU_DVB_STANDARD_AAC)||(MainDspCodeType == AU_DVB_STANDARD_MS10_DDT))
6967 {
6968 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1)&0xFFFF) < 32000) // check if less than 32KHz
6969 outType_tmp = HDMI_OUT_PCM;
6970 }
6971 else if ((MainDspCodeType != AU_DVB_STANDARD_AC3) &&
6972 (MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
6973 (MainDspCodeType != AU_DVB_STANDARD_DTS) &&
6974 (MainDspCodeType != AU_DVB_STANDARD_DTSLBR))
6975 {
6976 outType_tmp = HDMI_OUT_PCM;
6977 }
6978
6979 break;
6980 }
6981
6982 case E_AUDIO_INFO_HDMI_IN:
6983 {
6984 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
6985 {
6986 u8NonPcmPath = ADEC2; /* R2 */
6987 MainDspCodeType = Dsp2CodeType;
6988 }
6989 else
6990 {
6991 u8NonPcmPath = ADEC1; /* R2 */
6992 MainDspCodeType = Dsp1CodeType;
6993 }
6994
6995 if((HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE) ||(outType==HDMI_OUT_PCM)) /* if Type is not Dolby type, bypass */
6996 {
6997 u8NonPcmPath = ADEC1; /* R2 */
6998 outType_tmp = HDMI_OUT_PCM;
6999 }
7000
7001 break;
7002 }
7003
7004 case E_AUDIO_INFO_MM_IN:
7005 case E_AUDIO_INFO_GAME_IN:
7006 {
7007 if(HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS)
7008 {
7009 MainDspCodeType = Dsp2CodeType;
7010 u8NonPcmPath = ADEC2; /* R2 */
7011 }
7012 else
7013 {
7014 MainDspCodeType = Dsp1CodeType;
7015 u8NonPcmPath = ADEC1; /* R2 */
7016 }
7017
7018 if((MainDspCodeType == AU_DVB_STANDARD_AAC)||(MainDspCodeType == AU_DVB_STANDARD_MS10_DDT))
7019 {
7020 if(u8NonPcmPath == ADEC1)
7021 {
7022 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1)&0xFFFF) < 32000) // check if less than 32KHz
7023 {
7024 outType_tmp = HDMI_OUT_PCM;
7025 u8NonPcmPath = ADEC1; /* R2 */
7026 }
7027 }
7028 else
7029 {
7030 if((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC2)&0xFFFF) < 32000) // check if less than 32KHz
7031 {
7032 outType_tmp = HDMI_OUT_PCM;
7033 u8NonPcmPath = ADEC1; /* R2 */
7034 }
7035 }
7036 }
7037 else
7038 {
7039 if (g_AudioVars2->g_hbr_bypass_enable == true)
7040 {
7041 if ((MainDspCodeType != AU_DVB_STANDARD_AC3) &&
7042 (MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
7043 (MainDspCodeType != AU_DVB_STANDARD_DTS) &&
7044 (MainDspCodeType != AU_DVB_STANDARD_DTSLBR) &&
7045 (MainDspCodeType != AU_DVB_STANDARD_DTSHD_ADO) &&
7046 (MainDspCodeType != AU_DVB_STANDARD_DolbyTrueHD_Bypass))
7047 {
7048 outType_tmp = HDMI_OUT_PCM;
7049 u8NonPcmPath = ADEC1; /* R2 */
7050 }
7051 }
7052 else
7053 {
7054 if ((MainDspCodeType != AU_DVB_STANDARD_AC3) &&
7055 (MainDspCodeType != AU_DVB_STANDARD_AC3P) &&
7056 (MainDspCodeType != AU_DVB_STANDARD_DTS)&&
7057 (MainDspCodeType != AU_DVB_STANDARD_DTSLBR))
7058 {
7059 outType_tmp = HDMI_OUT_PCM;
7060 u8NonPcmPath = ADEC1; /* R2 */
7061 }
7062 }
7063 }
7064 break;
7065 }
7066
7067 default:
7068 {
7069 outType_tmp = HDMI_OUT_PCM;
7070 u8NonPcmPath = ADEC1; /*R2 */
7071 break;
7072 }
7073 }
7074
7075
7076 if (outType_tmp == HDMI_OUT_NONPCM)
7077 {
7078 /* Non-PCM in R2 */
7079 HAL_AUR2_WriteByte(REG_R2_HDMI_NONPCM_PATH, u8NonPcmPath);
7080 AUDIO_DELAY1MS(5);
7081 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, ADEC1, 2, 0); /* Non-PCM */
7082 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, ADEC2, 2, 0); /* Non-PCM */
7083 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select R2 */
7084 HAL_AUDIO_WriteMaskByte((REG_M2D_MAILBOX_SPDIF_CTRL+1), 0x20, 0x20); /* NONPCM Mode */
7085 HAL_AUDIO_WriteMaskByte(0x2C48, 0x80, 0x80); // enable synthesizer
7086 HAL_AUDIO_WriteMaskByte(0x2CB1, 0x04, 0x04); //sel HDMI TX clock from synthesizer
7087 }
7088 else
7089 {
7090 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, ADEC1, 1, 0); /* PCM Mode */
7091 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_HDMI_TYPE, ADEC2, 1, 0); /* PCM Mode */
7092 HAL_AUDIO_WriteMaskByte((REG_M2D_MAILBOX_SPDIF_CTRL+1), 0x20, 0x00); /* PCM Mode */
7093 HAL_AUDIO_WriteMaskByte(0x2CB1, 0x04, 0x00);
7094 HAL_AUDIO_WriteMaskByte(0x2C48, 0x80, 0x00);
7095 }
7096
7097 g_AudioVars2->g_HDMINonPcmPath = u8NonPcmPath;
7098 }
7099
7100 ////////////////////////////////////////////////////////////////////////////////
7101 /// @brief \b Function \b Name: HAL_AUDIO_PCMCaptureInit()
7102 /// @brief \b Function \b Description: Select source for pcm capture
7103 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7104 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
7105 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7106 /// @param <RET> \b NONE :
7107 /// @param <GLOBAL> \b NONE :
7108 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID,const AUDIO_CAPTURE_SOURCE_TYPE eSource)7109 MS_BOOL HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID, const AUDIO_CAPTURE_SOURCE_TYPE eSource)
7110 {
7111 MS_BOOL ret = TRUE;
7112
7113 switch(eID)
7114 {
7115 case E_DEVICE0:
7116 g_pcm_capture_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
7117 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
7118 ret = HAL_AUDIO_PCMCapture_Stop(eID);
7119 break;
7120
7121 case E_DEVICE1:
7122 g_pcm_capture2_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
7123 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
7124 ret = HAL_AUDIO_PCMCapture_Stop(eID);
7125 break;
7126
7127 default:
7128 printf("\r\n =====PCMCapture_Init : unsupported DEVICE TYPE!!!=======");
7129 ret = FALSE;
7130 break;
7131 }
7132
7133 return ret;
7134 }
7135
7136 ////////////////////////////////////////////////////////////////////////////////
7137 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Start()
7138 /// @brief \b Function \b Description: captrue pcm data to DDR
7139 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7140 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7141 /// @param <RET> \b NONE :
7142 /// @param <GLOBAL> \b NONE :
7143 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)7144 MS_BOOL HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)
7145 {
7146 MS_BOOL ret = TRUE;
7147
7148 switch(eID)
7149 {
7150 case E_DEVICE0:
7151 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); // start
7152 break;
7153
7154 case E_DEVICE1:
7155 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); //start
7156 break;
7157
7158 default:
7159 printf("\r\n =====PCMCapture_Start : unsupported DEVICE TYPE!!!=======");
7160 ret = FALSE;
7161 break;
7162 }
7163
7164 return ret;
7165 }
7166
7167
7168 ////////////////////////////////////////////////////////////////////////////////
7169 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Stop()
7170 /// @brief \b Function \b Description: stop captrue pcm data from DDR
7171 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7172 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7173 /// @param <RET> \b NONE :
7174 /// @param <GLOBAL> \b NONE :
7175 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)7176 MS_BOOL HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)
7177 {
7178 MS_BOOL ret = TRUE;
7179 MS_U8 flagCount = 0;
7180
7181 switch(eID)
7182 {
7183 case E_DEVICE0:
7184 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0); // stop
7185 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0);
7186 do
7187 {
7188 MsOS_DelayTask(2);
7189 flagCount ++;
7190 if (flagCount > 100)
7191 {
7192 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
7193 break;
7194 }
7195 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) > 0);
7196 break;
7197
7198 case E_DEVICE1:
7199 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0); //stop
7200 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0);
7201 do
7202 {
7203 MsOS_DelayTask(2);
7204 flagCount ++;
7205 if (flagCount > 100)
7206 {
7207 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
7208 break;
7209 }
7210 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) > 0);
7211 break;
7212
7213 default:
7214 printf("\r\n =====PCMCapture_Stop : unsupported DEVICE TYPE!!!=======");
7215 ret = FALSE;
7216 break;
7217 }
7218
7219 return ret;
7220 }
7221
7222
7223 ////////////////////////////////////////////////////////////////////////////////
7224 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Read()
7225 /// @brief \b Function \b Description: captrue pcm data from DDR to device
7226 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7227 /// @param <IN> \b void* : destination buffer pointer
7228 /// @param <IN> \b MS_U32 : buffer size need transfered in byte
7229 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7230 /// @param <RET> \b NONE :
7231 /// @param <GLOBAL> \b NONE :
7232 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID,void * buffer,const MS_U32 bytes)7233 MS_BOOL HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID, void* buffer, const MS_U32 bytes)
7234 {
7235 MS_BOOL ret = TRUE;
7236 MS_VIRT buffer_tmp = (MS_VIRT)buffer;
7237 MS_U32 request_size = bytes;
7238 MS_U32 read_ptr_mailbox = 0;
7239 MS_U32 write_ptr_mailbox = 0;
7240 MS_PHY pcm_capture_base_addr_tmp = 0;
7241 MS_PHY pcm_capture_read_addr_tmp = 0;
7242 MS_PHY pcm_capture_write_addr_tmp = 0;
7243 MS_S32 avail_size = 0;
7244
7245 switch(eID)
7246 {
7247 case E_DEVICE0:
7248 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE_DDR_RdPtr;
7249 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE_DDR_WrPtr;
7250 pcm_capture_base_addr_tmp = g_pcm_capture_base_addr;
7251 break;
7252
7253 case E_DEVICE1:
7254 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr;
7255 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr;
7256 pcm_capture_base_addr_tmp = g_pcm_capture2_base_addr;
7257 break;
7258
7259 default:
7260 printf("\r\n =====PCMCapture_Read : unsupported DEVICE TYPE!!!=======\n");
7261 ret = FALSE;
7262 break;
7263 }
7264
7265 if (ret == FALSE)
7266 return ret;
7267
7268 //get read & write pointer
7269 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(read_ptr_mailbox) * BYTES_IN_MIU_LINE);
7270 pcm_capture_write_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(write_ptr_mailbox) * BYTES_IN_MIU_LINE);
7271 avail_size = (MS_S32)(pcm_capture_write_addr_tmp - pcm_capture_read_addr_tmp);
7272 if (avail_size < 0)
7273 {
7274 avail_size += (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE);
7275 }
7276
7277 // if overflow , return false
7278 if (avail_size >= ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE - DSP2_PCM_CAPTURE_COPY_LINESIZE) * BYTES_IN_MIU_LINE))
7279 {
7280 printf("\r\n ===== PCM DATA OVERFLOW !!!=======\n");
7281
7282 HAL_AUDIO_PCMCapture_Stop(eID);
7283 HAL_AUDIO_PCMCapture_Start(eID);
7284 ret = FALSE;
7285 return ret;
7286 }
7287
7288 // if no enough data, do nothing.
7289 if (avail_size < request_size)
7290 {
7291 //printf("\r\n ===== no enough data, do nothing !!!===avail_size %d reguest %x====\n", avail_size, request_size);
7292 ret = FALSE;
7293 return ret;
7294 }
7295
7296 //copy data to destination.
7297 do
7298 {
7299 MS_U32 size_tmp = (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)) - pcm_capture_read_addr_tmp;
7300
7301 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
7302 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
7303
7304 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(pcm_capture_read_addr_tmp), size_tmp);
7305 MsOS_FlushMemory();
7306
7307 pcm_capture_read_addr_tmp += size_tmp;
7308 if (pcm_capture_read_addr_tmp == (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)))
7309 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp;
7310
7311 buffer_tmp += size_tmp;
7312 avail_size -= size_tmp;
7313 request_size -= size_tmp;
7314
7315 } while (request_size > 0);
7316
7317 //update read pointer
7318 HAL_AUDIO_WriteReg(read_ptr_mailbox, ((pcm_capture_read_addr_tmp - pcm_capture_base_addr_tmp) / BYTES_IN_MIU_LINE));
7319
7320 return ret;
7321 }
7322
7323 ////////////////////////////////////////////////////////////////////////////////
7324 /// @brief \b Function \b Name: HAL_AUDIO_SetDataCaptureSource()
7325 /// @brief \b Function \b Description: Select source for data capture
7326 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7327 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
7328 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7329 /// @param <RET> \b NONE :
7330 /// @param <GLOBAL> \b NONE :
7331 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID,AUDIO_CAPTURE_SOURCE_TYPE eSource)7332 MS_BOOL HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID, AUDIO_CAPTURE_SOURCE_TYPE eSource)
7333 {
7334 MS_U32 u32ControlAddress;
7335 MS_BOOL ret = TRUE;
7336
7337 HALAUDIO_CHECK_SHM_INIT;
7338
7339 switch(eID)
7340 {
7341 case E_DEVICE0:
7342 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL;
7343 break;
7344
7345 case E_DEVICE1:
7346 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
7347 break;
7348
7349 default:
7350 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
7351 return FALSE;
7352 }
7353
7354 switch(eSource)
7355 {
7356 case E_CAPTURE_CH5:
7357 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH5);
7358 break;
7359
7360 case E_CAPTURE_CH6:
7361 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH6);
7362 break;
7363
7364 case E_CAPTURE_CH7:
7365 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH7);
7366 break;
7367
7368 case E_CAPTURE_CH8:
7369 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH8);
7370 break;
7371
7372 case E_CAPTURE_ADC:
7373 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
7374 break;
7375
7376 case E_CAPTURE_ADC2:
7377 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
7378 break;
7379
7380 case E_CAPTURE_PCM_SE:
7381 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_Raw_Delay_SE);
7382 break;
7383
7384 case E_CAPTURE_MIXER:
7385 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_MIXER);
7386 break;
7387
7388 case E_CAPTURE_ADC1_AUIN0_INPUT:
7389 case E_CAPTURE_ADC1_AUIN1_INPUT:
7390 case E_CAPTURE_ADC1_AUIN2_INPUT:
7391 case E_CAPTURE_ADC1_AUIN3_INPUT:
7392 case E_CAPTURE_ADC1_AUIN4_INPUT:
7393 case E_CAPTURE_ADC1_AUIN5_INPUT:
7394 case E_CAPTURE_ADC1_AUMIC_INPUT:
7395 {
7396 MS_U8 u8temp = 0;
7397
7398 //check if ADC1 is occupied by main or sub channel
7399 if((LONIBBLE(g_AudioVars2->eMainAudioSource) == 2 || LONIBBLE(g_AudioVars2->eSubAudioSource) == 2))
7400 {
7401 printf("===The audio capture setting is failed by the following reason:=== \n");
7402 printf("The input setting of ADC1 is occupied by main or sub channel\n");
7403 ret = FALSE;
7404 break;
7405 }
7406
7407 //switch source of ADC1
7408 if (eSource == E_CAPTURE_ADC1_AUIN0_INPUT)
7409 {
7410 u8temp = 0x00;
7411 }
7412 else if (eSource == E_CAPTURE_ADC1_AUIN1_INPUT)
7413 {
7414 u8temp = 0x01;
7415 }
7416 else if (eSource == E_CAPTURE_ADC1_AUIN2_INPUT)
7417 {
7418 u8temp = 0x02;
7419 }
7420 else if (eSource == E_CAPTURE_ADC1_AUIN3_INPUT)
7421 {
7422 u8temp = 0x03;
7423 }
7424 else if (eSource == E_CAPTURE_ADC1_AUIN4_INPUT)
7425 {
7426 u8temp = 0x04;
7427 }
7428 else if (eSource == E_CAPTURE_ADC1_AUIN5_INPUT)
7429 {
7430 u8temp = 0x05;
7431 }
7432 else if (eSource == E_CAPTURE_ADC1_AUMIC_INPUT)
7433 {
7434 u8temp = 0x07;
7435 }
7436
7437 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xE0, (u8temp<<5));
7438 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
7439 break;
7440 }
7441
7442 case E_CAPTURE_ADC2_AUIN0_INPUT:
7443 case E_CAPTURE_ADC2_AUIN1_INPUT:
7444 case E_CAPTURE_ADC2_AUIN2_INPUT:
7445 case E_CAPTURE_ADC2_AUIN3_INPUT:
7446 case E_CAPTURE_ADC2_AUIN4_INPUT:
7447 case E_CAPTURE_ADC2_AUIN5_INPUT:
7448 case E_CAPTURE_ADC2_AUMIC_INPUT:
7449 {
7450 MS_U8 u8temp = 0;
7451
7452 //check if ADC2 is occupied by main or sub channel
7453 if((LONIBBLE(g_AudioVars2->eMainAudioSource) == 9 || LONIBBLE(g_AudioVars2->eSubAudioSource) == 9))
7454 {
7455 printf("===The audio capture setting is faiedl by the following reason:=== \n");
7456 printf("The input setting of ADC2 is occupied by main or sub channel \n");
7457 ret = FALSE;
7458 break;
7459 }
7460
7461 //switch source of ADC2
7462 if (eSource == E_CAPTURE_ADC2_AUIN0_INPUT)
7463 {
7464 u8temp = 0x00;
7465 }
7466 else if (eSource == E_CAPTURE_ADC2_AUIN1_INPUT)
7467 {
7468 u8temp = 0x01;
7469 }
7470 else if (eSource == E_CAPTURE_ADC2_AUIN2_INPUT)
7471 {
7472 u8temp = 0x02;
7473 }
7474 else if (eSource == E_CAPTURE_ADC2_AUIN3_INPUT)
7475 {
7476 u8temp = 0x03;
7477 }
7478 else if (eSource == E_CAPTURE_ADC2_AUIN4_INPUT)
7479 {
7480 u8temp = 0x04;
7481 }
7482 else if (eSource == E_CAPTURE_ADC2_AUIN5_INPUT)
7483 {
7484 u8temp = 0x05;
7485 }
7486 else if (eSource == E_CAPTURE_ADC2_AUMIC_INPUT)
7487 {
7488 u8temp = 0x07;
7489 }
7490 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x1C, (u8temp<<2) );
7491 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
7492 break;
7493 }
7494
7495 default:
7496 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
7497 ret = FALSE;
7498 break;
7499 }
7500
7501 return ret;
7502 }
7503
_AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId)7504 MS_BOOL _AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId)
7505 {
7506 return TRUE;
7507 }
7508
AU_GetDecID(AUDIO_DEC_ID * DecPriority,AudioDecStatus_t * p_AudioDecStatus)7509 AUDIO_DEC_ID AU_GetDecID(AUDIO_DEC_ID *DecPriority, AudioDecStatus_t * p_AudioDecStatus)
7510 {
7511 #if defined (CONFIG_UTOPIA_ANDROID_L)
7512 MS_U8 u8Index = 0;
7513 MS_U8 u8Loop = 0;
7514 #else
7515 int u8Index = 0;
7516 int u8Loop = 0;
7517 #endif
7518 AUDIO_DEC_ID DecID = AU_DEC_INVALID;
7519
7520 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7521 {
7522 u8Index = AU_DEC_MAX - 1;
7523 }
7524
7525 do
7526 {
7527 DecID = DecPriority[u8Index];
7528 if (DecID != AU_DEC_INVALID)
7529 {
7530 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7531 if ((HAL_MAD_GetAudioCapability(DecID, p_AudioDecStatus) == TRUE) &&
7532 (g_AudioVars2->AudioDecStatus[DecID].bConnect == FALSE))
7533 {
7534 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7535 break;
7536 }
7537 }
7538
7539 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7540 {
7541 u8Index--;
7542 }
7543 else
7544 {
7545 u8Index++;
7546 }
7547
7548 u8Loop++;
7549 } while (u8Loop < AU_DEC_MAX);
7550
7551 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7552 return DecID;
7553 }
7554
HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)7555 AUDIO_DEC_ID HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)
7556 {
7557 AUDIO_DEC_ID DecRet = AU_DEC_INVALID;
7558
7559 switch (p_AudioDecStatus->eSourceType)
7560 {
7561 case E_AUDIO_INFO_HDMI_IN:
7562 DecRet = AU_GetDecID(HDMIDecPriority, p_AudioDecStatus);
7563 break;
7564 case E_AUDIO_INFO_DTV_IN:
7565 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7566 break;
7567 case E_AUDIO_INFO_MM_IN:
7568 case E_AUDIO_INFO_GAME_IN:
7569 if (p_AudioDecStatus->eMMType == AUDIO_MM_VD)
7570 {
7571 DecRet = AU_GetDecID(VDDecPriority, p_AudioDecStatus);
7572 }
7573 else
7574 {
7575 DecRet = AU_GetDecID(MMDecPriority, p_AudioDecStatus);
7576 }
7577 break;
7578 default:
7579 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7580 break;
7581 }
7582
7583 switch (DecRet)
7584 {
7585 case AU_DEC_ID1:
7586 p_AudioDecStatus->eAfifoSource = E_AFIFO_0;
7587 break;
7588 case AU_DEC_ID2:
7589 p_AudioDecStatus->eAfifoSource = E_AFIFO_1;
7590 break;
7591 case AU_DEC_ID3:
7592 p_AudioDecStatus->eAfifoSource = E_AFIFO_2;
7593 break;
7594 default:
7595 p_AudioDecStatus->eAfifoSource = E_AFIFO_MAX;
7596 break;
7597 }
7598
7599 printf("DecID = %d %s() %d \n",DecRet,__FUNCTION__,__LINE__);
7600 return DecRet;
7601 }
7602
HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId,AudioDecStatus_t * p_AudioDecStatus)7603 MS_BOOL HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus)
7604 {
7605 AUDIO_DSP_ID DSP_id = AUDIO_DSP_ID_ALL;
7606 MS_BOOL bRet = FALSE;
7607
7608 HALAUDIO_CHECK_SHM_INIT;
7609
7610 switch(p_AudioDecStatus->eStcSource)
7611 {
7612 case E_TSP_0:
7613 if (DecId == AU_DEC_ID1)
7614 {
7615 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECT, ADEC1, 0, 0);
7616 }
7617 else if(DecId == AU_DEC_ID3)
7618 {
7619 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECT, ADEC2, 0, 0);
7620 }
7621 break;
7622
7623 case E_TSP_1:
7624 if (DecId == AU_DEC_ID1)
7625 {
7626 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECT, ADEC1, 1, 0);
7627 }
7628 else if(DecId == AU_DEC_ID3)
7629 {
7630 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_STC_SELECT, ADEC2, 1, 0);
7631 }
7632 break;
7633
7634 case E_TSP_MAX:
7635 default:
7636 break;
7637 }
7638
7639 //HALAUDIO_ERROR("\033[1;31m [%s: %d][DecId = %d, eAudFormat = %d, g_AudioVars2->AudioDecStatus[DecId].eAudFormat = %d] \033[0m \n", __FILE__, __LINE__,
7640 // DecId,
7641 // p_AudioDecStatus->eAudFormat,
7642 // g_AudioVars2->AudioDecStatus[DecId].eAudFormat);
7643 if (p_AudioDecStatus->eGroup == E_CONNECT_MAIN)
7644 {
7645 g_AudioVars2->eAudioSource = p_AudioDecStatus->eSourceType;
7646 }
7647
7648 if ((DecId == AU_DEC_ID1) && (g_AudioVars2->AudioDecStatus[DecId].eSourceType == E_AUDIO_INFO_DTV_IN))
7649 {
7650 HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT,AUDIO_PATH_5);
7651 }
7652
7653 if((g_AudioVars2->AudioDecStatus[DecId].eAudFormat == p_AudioDecStatus->eAudFormat) &&
7654 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == p_AudioDecStatus->eSourceType) &&
7655 (g_AudioVars2->AudioDecStatus[DecId].eGroup == p_AudioDecStatus->eGroup) &&
7656 (g_AudioVars2->AudioDecStatus[DecId].eStcSource == p_AudioDecStatus->eStcSource) &&
7657 (g_AudioVars2->AudioDecStatus[DecId].bIsAD == p_AudioDecStatus->bIsAD))
7658 {
7659 HALAUDIO_PRINT("%s() - DSP code is the same\n",__FUNCTION__);
7660 return bRet;
7661 }
7662
7663 if (DecId == AU_DEC_ID3)
7664 {
7665 DSP_id = AUDIO_DSP_ID_SND;
7666 }
7667 else if (DecId == AU_DEC_ID1)
7668 {
7669 DSP_id = AUDIO_DSP_ID_DEC;
7670 }
7671 else if (DecId == AU_DEC_ID2)
7672 {
7673 // Patch, SIF only decode in SND_DSP, but this enum is same as AUDIO_DSP_ID_SND
7674 DSP_id = AUDIO_DSP_ID_ALL;
7675 }
7676
7677 HAL_MAD_DvbFLockSynthesizer_En();
7678
7679 g_AudioVars2->AudioDecStatus[DecId].eDSPId = DSP_id;
7680 p_AudioDecStatus->eDSPId = DSP_id;
7681
7682 switch ( p_AudioDecStatus->eAudFormat)
7683 {
7684 case MSAPI_AUD_DVB_MPEG:
7685 case MSAPI_AUD_DVB_AC3:
7686 case MSAPI_AUD_DVB_AC3P:
7687 case MSAPI_AUD_DVB_MP3:
7688 case MSAPI_AUD_DVB_AAC:
7689 case MSAPI_AUD_DVB_XPCM:
7690 case MSAPI_AUD_DVB_RA8LBR:
7691 case MSAPI_AUD_DVB_WMA:
7692 case MSAPI_AUD_DVB_DTS:
7693 case MSAPI_AUD_DVB_DTSLBR:
7694 case MSAPI_AUD_DVB_DTSHDADO:
7695 case MSAPI_AUD_DVB_MS10_DDT:
7696 case MSAPI_AUD_DVB_MS10_DDC:
7697 case MSAPI_AUD_DVB_WMA_PRO:
7698 case MSAPI_AUD_DVB_FLAC:
7699 case MSAPI_AUD_DVB_VORBIS:
7700 case MSAPI_AUD_DVB_AMR_NB:
7701 case MSAPI_AUD_DVB_AMR_WB:
7702 case MSAPI_AUD_DVB_DRA:
7703 bRet = HAL_AUDIO_SetSystem2(DecId, p_AudioDecStatus->eAudFormat);
7704 break;
7705
7706 default:
7707 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, p_AudioDecStatus->eAudFormat);
7708 break;
7709 }
7710
7711 return bRet;
7712 }
7713
_AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId)7714 MS_BOOL _AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId)
7715 {
7716 return TRUE;
7717 }
7718
HAL_AUDIO_ReloadCode(AUDIO_DSP_ID id,AUDIO_DSP_CODE_TYPE code_type)7719 MS_BOOL HAL_AUDIO_ReloadCode(AUDIO_DSP_ID id, AUDIO_DSP_CODE_TYPE code_type)
7720 {
7721 return TRUE;
7722 }
7723
HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id,void * pau_info)7724 MS_BOOL HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id, void * pau_info)
7725 {
7726 return TRUE;
7727 }
7728
HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId,En_DVB_decSystemType Param)7729 MS_BOOL HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId, En_DVB_decSystemType Param)
7730 {
7731 MS_U32 regDecoderType = REG_R2_DECODE1_TYPE;
7732 MS_BOOL bRet = TRUE;
7733
7734 if(DecId == AU_DEC_ID3)
7735 {
7736 regDecoderType = REG_R2_DECODE2_TYPE;
7737 }
7738 else if (DecId == AU_DEC_ID1)
7739 {
7740 regDecoderType = REG_R2_DECODE1_TYPE;
7741 }
7742 else if (DecId == AU_DEC_ID2)
7743 {
7744 // AU_DEC_ID2 only for ATV SIF
7745 // For other case should not use AU_DEC_ID2
7746 return bRet;
7747 }
7748
7749 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = Param;
7750
7751 switch ( Param )
7752 {
7753 case MSAPI_AUD_DVB_MPEG:
7754 case MSAPI_AUD_DVB_MP3:
7755 HAL_AUR2_WriteByte(regDecoderType, adec_type_mpeg);
7756 if(DecId == AU_DEC_ID3)
7757 {
7758 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
7759 }
7760 else
7761 {
7762 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
7763 }
7764 break;
7765
7766 case MSAPI_AUD_DVB_MS10_DDC:
7767 case MSAPI_AUD_DVB_AC3P:
7768 case MSAPI_AUD_DVB_AC3:
7769 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7770 HAL_AUR2_WriteByte(regDecoderType, adec_type_ac3);
7771 if(DecId == AU_DEC_ID3)
7772 {
7773 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
7774 }
7775 else
7776 {
7777 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
7778 }
7779 break;
7780
7781 case MSAPI_AUD_DVB_AAC:
7782 case MSAPI_AUD_DVB_MS10_DDT:
7783 if (g_AudioVars2->DolbyAACFlag == 1)
7784 {
7785 HAL_AUR2_WriteByte(regDecoderType, adec_type_aac);
7786 }
7787 else
7788 {
7789 HAL_AUR2_WriteByte(regDecoderType, adec_type_gaac);
7790 }
7791 if(DecId == AU_DEC_ID3)
7792 {
7793 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
7794 }
7795 else
7796 {
7797 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
7798 }
7799 break;
7800
7801 case MSAPI_AUD_DVB_XPCM:
7802 HAL_AUR2_WriteByte(regDecoderType, adec_type_xpcm);
7803 if(DecId == AU_DEC_ID3)
7804 {
7805 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
7806 }
7807 else
7808 {
7809 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
7810 }
7811 break;
7812
7813 case MSAPI_AUD_DVB_RA8LBR:
7814 HAL_AUR2_WriteByte(regDecoderType, adec_type_ra8);
7815 if(DecId == AU_DEC_ID3)
7816 {
7817 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7818 }
7819 else
7820 {
7821 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7822 }
7823 break;
7824
7825 case MSAPI_AUD_DVB_WMA:
7826 HAL_AUR2_WriteByte(regDecoderType, adec_type_wma);
7827 if(DecId == AU_DEC_ID3)
7828 {
7829 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA, TRUE);
7830 }
7831 else
7832 {
7833 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
7834 }
7835 break;
7836
7837 case MSAPI_AUD_DVB_DTS:
7838 case MSAPI_AUD_DVB_DTSLBR:
7839 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7840 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7841 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7842 if(DecId == AU_DEC_ID3)
7843 {
7844 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7845 }
7846 else
7847 {
7848 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7849 }
7850 break;
7851
7852 case MSAPI_AUD_DVB_WMA_PRO:
7853 HAL_AUR2_WriteByte(regDecoderType, adec_type_wmap);
7854 if(DecId == AU_DEC_ID3)
7855 {
7856 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7857 }
7858 else
7859 {
7860 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7861 }
7862 break;
7863
7864 case MSAPI_AUD_DVB_DRA:
7865 HAL_AUR2_WriteByte(regDecoderType, adec_type_dra);
7866 if(DecId == AU_DEC_ID3)
7867 {
7868 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DRA, TRUE);
7869 }
7870 else
7871 {
7872 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
7873 }
7874 break;
7875
7876 case MSAPI_AUD_DVB_FLAC:
7877 HAL_AUR2_WriteByte(regDecoderType, adec_type_flac);
7878 if(DecId == AU_DEC_ID3)
7879 {
7880 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_FLAC, TRUE);
7881 }
7882 else
7883 {
7884 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
7885 }
7886 break;
7887
7888 case MSAPI_AUD_DVB_VORBIS:
7889 HAL_AUR2_WriteByte(regDecoderType, adec_type_vorbis);
7890 if(DecId == AU_DEC_ID3)
7891 {
7892 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7893 }
7894 else
7895 {
7896 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7897 }
7898 break;
7899
7900 case MSAPI_AUD_DVB_AMR_NB:
7901 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7902 if(DecId == AU_DEC_ID3)
7903 {
7904 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7905 }
7906 else
7907 {
7908 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7909 }
7910 break;
7911
7912 case MSAPI_AUD_DVB_AMR_WB:
7913 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7914 if(DecId == AU_DEC_ID3)
7915 {
7916 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7917 }
7918 else
7919 {
7920 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7921 }
7922 break;
7923
7924 case MSAPI_AUD_DVB_DTSHDADO:
7925 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7926 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7927 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7928 if(DecId == AU_DEC_ID3)
7929 {
7930 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7931 }
7932 else
7933 {
7934 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7935 }
7936 break;
7937
7938 default:
7939 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, Param);
7940 break;
7941 }
7942
7943 return bRet;
7944 }
7945
7946 ////////////////////////////////////////////////////////////////////////////////
7947 /// @brief \b Function \b Name: HAL_AUDIO_GetDDRInfo()
7948 /// @brief \b Function \b Description: Return Audio DDR info
7949 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
7950 /// @param <IN> \b EN_AUDIO_DDRINFO : DDR info
7951 /// @param <OUT> \b MS_U32 : return DDR info
7952 /// @param <RET> \b NONE :
7953 /// @param <GLOBAL> \b NONE :
7954 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId,EN_AUDIO_DDRINFO DDRInfo)7955 MS_PHY HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo)
7956 {
7957 MS_PHY DDR_ADDR = 0;
7958 MS_PHY DDR_ADDR_LINE_BASE = 0;
7959 MS_PHY DDR_ADDR_TMP;
7960 MS_PHY DDR_Value = 0;
7961 if (DecId == AU_DEC_ID1)
7962 {
7963 switch(DDRInfo)
7964 {
7965 case E_AUD_MEMORY_BASE: //use DSP2 base instead
7966 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7967 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7968 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7969 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7970 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7971 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7972 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7973 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7974 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7975 DDR_Value = DDR_ADDR;
7976 break;
7977 case E_AUD_MEMORY_SIZE:
7978 //TODO
7979 break;
7980 default:
7981 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7982 break;
7983 }
7984 }
7985 else if(DecId == AU_DEC_ID3)
7986 {
7987 switch(DDRInfo)
7988 {
7989 case E_AUD_MEMORY_BASE:
7990 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7991 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7992 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7993 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7994 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7995 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7996 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7997 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7998 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7999 DDR_Value = DDR_ADDR;
8000 break;
8001 case E_AUD_MEMORY_SIZE:
8002 //TODO
8003 break;
8004 default:
8005 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
8006 break;
8007 }
8008 }
8009 else
8010 {
8011 HALAUDIO_ERROR ("%s: UN-KNOW DecId (0x%x) !!\r\n", __FUNCTION__, DecId);
8012 }
8013 return DDR_Value;
8014 }
8015
8016 ////////////////////////////////////////////////////////////////////////////////
8017 /// @brief \b Function \b Name: HAL_AUDIO_DumpDspInfo()
8018 /// @brief \b Function \b Description: Dump DSP infomation
8019 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DumpDspInfo(void)8020 void HAL_AUDIO_DumpDspInfo(void)
8021 {
8022 MS_U32 tmp_H, tmp_L, tmp_M;
8023 MS_U32 result = 0;
8024 MS_U32 ES_Lvl, PCM_Lvl;
8025 static MS_U32 preSysTime, prv_mmFile_APTS;
8026 MS_U32 sysTime, mmFile_APTS;
8027
8028 if(g_AudioDumpInfoCtrl == Audio_DumpInfo_Off)
8029 {
8030 return;
8031 }
8032
8033 ES_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
8034 PCM_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC1);
8035
8036 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Avsync) != 0)
8037 {
8038 sysTime = MsOS_GetSystemTime();
8039 printf("[%08u]", sysTime);
8040
8041 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8042 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
8043
8044 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFFFF;
8045 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFF;
8046 printf("PCM=%04X(%04X,%04X)|", PCM_Lvl, tmp_H, tmp_L);
8047
8048 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8049 printf("play=%X", tmp_L);
8050
8051 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
8052 printf("<%04X>,", tmp_L);
8053
8054 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
8055 tmp_M = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, 0, 0)&0x0F;
8056 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
8057 printf("State=%X,%X(%X)|", tmp_L,tmp_M, tmp_H);
8058
8059 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8060 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8061 printf("frmCnt:%04X,", tmp_L);
8062 printf("%04X,", tmp_H);
8063
8064 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8065 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8066 printf("%02X,", tmp_L);
8067 printf("%02X,", tmp_H);
8068
8069 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_1STPTS_CNT, ADEC1)&0x00FF;
8070 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_STC_CNT, ADEC1)&0x00FF;
8071 tmp_M = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_FLUSH_CNT, ADEC1)&0x00FF;
8072 printf("%02X,%02X,%02X|", tmp_L, tmp_H, tmp_M);
8073
8074 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_WR_IDX, ADEC1)&0xF;
8075 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_RD_IDX, ADEC1)&0xF;
8076 printf("tag:%01X,%01X|", tmp_L, tmp_H);
8077
8078 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_OFFSET, ADEC1)&0x00FFFFFF;
8079 printf("AvDly=%05X,", tmp_L);
8080
8081 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_STC, ADEC1);
8082 printf("STC=%d,", result/45);
8083
8084 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, ADEC1);
8085 printf("PTS=%d,", result/45);
8086
8087 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
8088 printf("cPTS=%d,", result/45);
8089
8090 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
8091 printf("|Td=%x\n", result/90);
8092 }
8093
8094 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Dec1) != 0)
8095 {
8096 sysTime = MsOS_GetSystemTime();
8097 printf("[%08u]", sysTime);
8098
8099 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8100 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
8101
8102 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFF;
8103 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFF;
8104 printf("PCM=%04X(%04X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
8105
8106 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_TYPE);
8107 printf("ID=%02X,", tmp_L);
8108
8109 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_TYPE, ADEC1)&0x00FF;
8110 printf("Type=%02X,", tmp_L);
8111
8112 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFFFF;
8113 printf("pState=%06X,", tmp_L);
8114
8115 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
8116 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
8117 printf("|Cmd=%02X,Stop=%02X|", tmp_L, tmp_H);
8118
8119 tmp_L = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER1_CFG);
8120 tmp_H = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER2_CFG);
8121 printf("Input_Mux:%02X,", tmp_L&0x7);
8122 printf("%02X,", tmp_H&0x7);
8123 printf("%02X|", (tmp_L>>16)&0x7);
8124
8125 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8126 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8127 printf("frmCnt:%04X,", tmp_L);
8128 printf("%04X,", tmp_H);
8129
8130 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8131 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8132 printf("%02X,", tmp_L);
8133 printf("%02X|", tmp_H);
8134
8135 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FFFF;
8136 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x0000FFFF;
8137 printf("Call:%04X,", tmp_L);
8138 printf("sMiss:%04X|", tmp_H);
8139
8140 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC1)&0x00FFFFFF;
8141 printf("pcm=%06X,", tmp_L);
8142
8143 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_R, ADEC1)&0x00FFFFFF;
8144 printf("%06X|", tmp_L);
8145
8146 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8147 printf("play=%X\n", tmp_L);
8148 }
8149
8150
8151 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_IoInfo) != 0)
8152 {
8153 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH5_CFG)) & 0x000F;
8154 printf("CH5 mux=0x%02X,", tmp_L);
8155
8156 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH6_CFG)) & 0x000F;
8157 printf("Ch6 mux=0x%02X,", tmp_L);
8158
8159 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH7_CFG)) & 0x000F;
8160 printf("Ch7 mux=0x%02X", tmp_L);
8161
8162 // Not define
8163 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC1)&0x00FFFFFF;
8164 printf("|DEC1=0x%06X,", tmp_L);
8165
8166 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC2)&0x00FFFFFF;
8167 printf("DEC2=0x%06X", tmp_L);
8168
8169 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_RAW+0);
8170 printf("|CH5=0x%06X,", tmp_L);
8171
8172 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_MUL_CH6+0);
8173 printf("CH6=0x%06X,", tmp_L);
8174
8175 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info2+IO_INFO2_SCART+0);
8176 printf("CH7=0x%06X", tmp_L);
8177
8178 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_DAC1_OUT+0);
8179 printf("|DAC1=0x%06X,", tmp_L);
8180
8181 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_IIS1_OUT+0);
8182 printf("I2S=0x%06X,", tmp_L);
8183
8184 tmp_L = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_IO_Info1+IO_INFO1_SPDIF_OUT+0);
8185 printf("SPDIF=0x%06X\n", tmp_L);
8186 }
8187
8188 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_AutoTest) != 0)
8189 {
8190 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x00FFFFFF;
8191 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x00FFFFFF;
8192 printf("[AutoTest][AUDIO][FrameCount][%d]\n", tmp_L);
8193 printf("[AutoTest][AUDIO][ErrorCount][%d]\n", tmp_H);
8194
8195 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
8196 printf("[AutoTest][AUDIO][SampleRate][%d]\n", tmp_L);
8197 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
8198 printf("[AutoTest][AUDIO][ACMod][%d]\n", tmp_L);
8199 }
8200
8201 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_mmFileAVsync) != 0)
8202 {
8203 sysTime = MsOS_GetSystemTime();
8204 printf("[%08u](%03u):", sysTime, sysTime - preSysTime);
8205 preSysTime = sysTime;
8206
8207 mmFile_APTS = HAL_MAD_GetCommInfo(Audio_Comm_infoType_1ms_PTS);
8208 printf("APTS:%07u(%03u)|", mmFile_APTS, mmFile_APTS - prv_mmFile_APTS);
8209 prv_mmFile_APTS = mmFile_APTS;
8210
8211 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1)&0xFFFF;
8212 printf("MM:%04X|", tmp_H);
8213
8214 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8215 printf("ES=%04X(%04X),", ES_Lvl, tmp_L);
8216
8217 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFF;
8218 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFFFF;
8219 printf("PCM=%04X(%06X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
8220
8221 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
8222 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
8223 printf("Cmd=%02X,Stop=%02X,", tmp_L, tmp_H);
8224
8225 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8226 printf("play=%X", tmp_L);
8227
8228 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
8229 printf("<%04X>,", tmp_L);
8230
8231 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
8232 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
8233 printf("State=%X(%X)|", tmp_L, tmp_H);
8234
8235 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8236 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8237 printf("frmCnt:%04X,", tmp_L);
8238 printf("%04X,", tmp_H);
8239
8240 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8241 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8242 printf("%02X,", tmp_L);
8243 printf("%02X|", tmp_H);
8244
8245 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_ID, DSP_MEM_TYPE_DM)&0x00FF;
8246 //printf("DEC_ID=%02X,", tmp_L);
8247
8248 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_DEC_TYPE, DSP_MEM_TYPE_DM)&0x00FF;
8249 //printf("Type=%02X,", tmp_L);
8250
8251 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFF;
8252 printf("pState=%04X,", tmp_L);
8253
8254 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FF;
8255 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x00000FFF;
8256 printf("Call:%02X,", tmp_L);
8257 printf("Miss:%03X\n", tmp_H);
8258 }
8259
8260 }
8261
8262
8263 #ifndef MSOS_TYPE_NUTTX
HAL_AUDIO_ResetTeeInfoShmToDefault(void)8264 MS_BOOL HAL_AUDIO_ResetTeeInfoShmToDefault(void)
8265 {
8266 if (pAudioTeeInfoShm == NULL)
8267 {
8268 return FALSE;
8269 }
8270 memset(pAudioTeeInfoShm, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
8271 audio_tee_enabled = g_bAudioTeeEnabled;
8272 audio_tee_mbx_initialized = g_bAudioTeeMbxInitialized;
8273 dec_dsp_secure_tee_accessed = g_bDecDspSecureTeeAccessed;
8274 snd_dsp_secure_tee_accessed = g_bSndDspSecureTeeAccessed;
8275 return TRUE;
8276 }
8277
HAL_AUDIO_AllocateTeeInfoShm(void)8278 AUDIO_TEE_INFO_SHARE_MEM *HAL_AUDIO_AllocateTeeInfoShm(void)
8279 {
8280 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
8281 MS_U32 u32ShmId = 0;
8282 AUDIO_TEE_INFO_SHARE_MEM *virtAddr = 0;
8283 MS_U32 u32BufSize = 0;
8284
8285 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)
8286 {
8287 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
8288
8289 if (pAudioTeeInfoShm->g_u32ClientCounter == 0)
8290 {
8291 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
8292 HAL_AUDIO_ResetTeeInfoShmToDefault();
8293 }
8294 }
8295 else
8296 {
8297 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)
8298 {
8299 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
8300 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
8301
8302 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
8303 HAL_AUDIO_ResetTeeInfoShmToDefault();
8304 }
8305 else
8306 {
8307 HALAUDIO_ERROR("SHM allocation for Audio TEE Info failed!\n");
8308 return NULL;
8309 }
8310 }
8311
8312 if (g_bAudioTeeInfoShmInitFlag == FALSE)
8313 {
8314 g_bAudioTeeInfoShmInitFlag = TRUE;
8315 pAudioTeeInfoShm->g_u32ClientCounter++;
8316 }
8317 #else
8318 pAudioTeeInfoShm = &gAudioTeeInfoShm;
8319
8320 if (g_bAudioTeeInfoShmInitFlag == FALSE)
8321 {
8322 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
8323 g_bAudioTeeInfoShmInitFlag = TRUE;
8324
8325 HAL_AUDIO_ResetTeeInfoShmToDefault();
8326 pAudioTeeInfoShm->g_u32ClientCounter++;
8327 }
8328 #endif
8329 return pAudioTeeInfoShm;
8330 }
8331
HAL_AUDIO_DeAllocateTeeInfoShm(void)8332 MS_BOOL HAL_AUDIO_DeAllocateTeeInfoShm(void)
8333 {
8334 AUDIO_TEE_INFO_SHARE_MEM * pAUDIOShared = NULL;
8335
8336 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
8337 MS_U32 u32ShmId = 0;
8338 MS_VIRT virtAddr = 0;
8339 MS_U32 u32BufSize = 0;
8340
8341 if (g_bAudioTeeInfoShmInitFlag == TRUE)
8342 {
8343 g_bAudioTeeInfoShmInitFlag = FALSE;
8344
8345 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, &virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
8346 {
8347 HALAUDIO_ERROR("%s() : No AUDIO TEE Info SHM is created!\n", __FUNCTION__);
8348 return FALSE;
8349 }
8350
8351 pAUDIOShared = (AUDIO_TEE_INFO_SHARE_MEM *)virtAddr;
8352 pAUDIOShared->g_u32ClientCounter--;
8353
8354 if (pAUDIOShared->g_u32ClientCounter == 0)
8355 {
8356 printf("free Audio TEE Info SHM data ...\n");
8357
8358 #if defined(MSOS_TYPE_LINUX)
8359 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, u32ShmId) == TRUE)
8360 {
8361 HALAUDIO_PRINT("Audio TEE Info SHM data is freed\n");
8362 }
8363 else
8364 {
8365 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
8366 return FALSE;
8367 }
8368 #endif
8369 }
8370 }
8371 #else
8372 pAUDIOShared = &gAudioTeeInfoShm;
8373
8374 if (g_bAudioTeeInfoShmInitFlag == TRUE)
8375 {
8376 HALAUDIO_PRINT("free Audio TEE Info SHM data ...\n");
8377 g_bAudioTeeInfoShmInitFlag = FALSE;
8378
8379 memset(pAUDIOShared, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
8380 }
8381 #endif
8382
8383 return TRUE;
8384 }
8385
HAL_AUDIO_RegisterMBX(void)8386 MS_BOOL HAL_AUDIO_RegisterMBX(void)
8387 {
8388 MS_U8 ClassNum=0;
8389 MBX_Result result;
8390 MBX_CPU_ID eHKCPU;
8391 MS_U32 u32TimeoutMillSecs = 10000;
8392
8393 if (pAudioTeeInfoShm == NULL)
8394 return FALSE;
8395 if (audio_tee_mbx_initialized == TRUE)
8396 return TRUE;
8397
8398 #if 1
8399 eHKCPU = E_MBX_CPU_MIPS;
8400 if ( E_MBX_SUCCESS != MApi_MBX_Init(eHKCPU, E_MBX_ROLE_HK, u32TimeoutMillSecs))
8401 {
8402 DBG_AUDIO_ERROR("Error> MBX init failed !!\n");
8403 return FALSE;
8404 }
8405 else
8406 {
8407 MApi_MBX_Enable(TRUE);
8408 }
8409 #endif
8410
8411 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass (E_MBX_CPU_MIPS_VPE1, "MAD", (MS_U8 *)&ClassNum))
8412 {
8413 DBG_AUDIO_ERROR("MAD MApi_MBX_QueryDynamicClass fail\n");
8414
8415 return FALSE;
8416 }
8417 result = MApi_MBX_RegisterMSG(ClassNum, 10);
8418 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
8419 {
8420 DBG_AUDIO_ERROR("HAL_AUDIO_RegisterMBX fail");
8421 return FALSE;
8422 }
8423 else
8424 {
8425 TEE_MBX_MSG_CLASS_SET(ClassNum);
8426 DBG_AUDIO("HAL_AUDIO_RegisterMBX ok");
8427 return TRUE;
8428 }
8429 }
8430
HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)8431 TEE_TO_REE_MBX_ACK_MSG_TYPE HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)
8432 {
8433 MS_U8 u8Index;
8434 MBX_Result result;
8435 REE_TO_TEE_MBX_MSG_TYPE msg_type1 = REE_TO_TEE_MBX_MSG_NULL;
8436
8437 AUDIO_TEE_INFO_SHM_CHECK_NULL;
8438
8439 if (audio_tee_enabled == FALSE)
8440 {
8441 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8442 }
8443 if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_DEC) == (REE_TO_TEE_MBX_MSG_TYPE_DEC))
8444 {
8445 if (dec_dsp_secure_tee_accessed == FALSE)
8446 {
8447 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8448 }
8449 else
8450 {
8451 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_DEC);
8452 }
8453 }
8454 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_SE) == (REE_TO_TEE_MBX_MSG_TYPE_SE))
8455 {
8456 if (snd_dsp_secure_tee_accessed == FALSE)
8457 {
8458 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8459 }
8460 else
8461 {
8462 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_SE);
8463 }
8464 }
8465 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_GENERAL) == (REE_TO_TEE_MBX_MSG_TYPE_GENERAL))
8466 {
8467
8468 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
8469 }
8470
8471 if (audio_tee_mbx_initialized == FALSE)
8472 {
8473 return TEE_TO_REE_MBX_ACK_MSG_INVALID;
8474 }
8475 REE_TO_TEE_MBX_MSG_INIT;
8476 MBX_MSG_SET_CLASSID(ree_to_tee_mbx_msg, tee_mbx_msg_class);
8477 MBX_MSG_SET_CMD(ree_to_tee_mbx_msg, msg_type1);
8478
8479 result = MApi_MBX_SendMsg(&(ree_to_tee_mbx_msg));
8480 if (E_MBX_SUCCESS!= result)
8481 {
8482 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8483 }
8484 // Receive Reply ACK from TEE side.
8485 memset(&(tee_to_ree_mbx_msg), 0, sizeof(MBX_Msg));
8486 MBX_MSG_SET_CLASSID(tee_to_ree_mbx_msg, tee_mbx_msg_class);
8487 do
8488 {
8489 result = MApi_MBX_RecvMsg(tee_mbx_msg_class, &(tee_to_ree_mbx_msg), 2000, MBX_CHECK_INSTANT_MSG);
8490 } while(E_MBX_SUCCESS != result);
8491
8492 u8Index = tee_to_ree_mbx_msg.u8Index;
8493 DBG_AUDIO("Recv TEE Ack Msg OK cmd:%x\n", u8Index);
8494
8495 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL == u8Index)
8496 {
8497 DBG_AUDIO_ERROR("RecvMsg TEE_TO_REE_MBX_MSG_ACK_FAIL..\n");
8498 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8499 }
8500 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS == u8Index)
8501 {
8502 DBG_AUDIO("RecvMsg TEE_TO_REE_MBX_MSG_ACK_SUCCESS..\n");
8503 }
8504
8505 return TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
8506 }
8507 #else
_MAD_Proc(void)8508 static void _MAD_Proc(void)
8509 {
8510 MS_U32 u32Events;
8511 MS_U8 u8Index = 0;
8512 MBX_Result result;
8513
8514 DBG_AUDIO("_MAD_Proc...........\n");
8515
8516 while (1)
8517 {
8518 MsOS_WaitEvent(_s32MadEventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
8519 u8Index = msg.u8Index;
8520
8521 memset(&TeeToReeMbxAckMsg, 0, sizeof(MBX_Msg));
8522 TEE_TO_REE_MBX_MSG_INIT(TeeToReeMbxAckMsg);
8523 MBX_MSG_SET_CLASSID(TeeToReeMbxAckMsg, msg.u8MsgClass);
8524 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS);
8525
8526 switch ( u8Index )
8527 {
8528 case REE_TO_TEE_MBX_MSG_HAL_AUDSP_DspLoadCode:
8529 {
8530 if (HAL_AUDSP_DspLoadCode(msg.u8Parameters[0]) == FALSE)
8531 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8532
8533 break;
8534 }
8535
8536 case REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr:
8537 {
8538 MS_U32 u32Bin_Base_Address, u32Mad_Base_Buffer_Adr;
8539 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));
8540 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));
8541 HAL_AUDIO_SetDspBaseAddr(msg.u8Parameters[0], u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
8542 break;
8543 }
8544
8545 default:
8546 {
8547 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8548 break;
8549 }
8550 }
8551
8552 result = MApi_MBX_SendMsg(&TeeToReeMbxAckMsg);
8553 if (E_MBX_SUCCESS != result)
8554 DBG_AUDIO("MAD Reply Ack fail classid: %x cmd:%x \n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8555 else
8556 DBG_AUDIO("MAD Reply Ack ok classid:%x cmd:%x\n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8557 }
8558 }
8559
HAL_AUDIO_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)8560 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
8561 {
8562 if(pMsg==NULL)
8563 {
8564 DBG_AUDIO("pMsg is a null pointer\n");
8565 return;
8566 }
8567 if (_s32MadEventId < 0)
8568 {
8569 DBG_AUDIO("MAD EventGroup Id is not valid...\n");
8570 return;
8571 }
8572 memcpy(&msg, pMsg, sizeof(MBX_Msg));
8573 MsOS_SetEvent(_s32MadEventId, 1);
8574 return;
8575 }
8576 #endif
8577
8578 ////////////////////////////////////////////////////////////////////////////////
8579 /// @brief \b Function \b Name: HAL_AUDIO_update_DspUsage()
8580 /// @brief \b Function \b Description: update DSP resource status when select input source
8581 /// @param <IN> \b AUDIO_SOURCE_INFO_TYPE : select input source type
8582 /// @param <OUT> \b NONE :
8583 /// @param <RET> \b NONE :
8584 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)8585 void HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)
8586 {
8587 HALAUDIO_CHECK_SHM_INIT;
8588
8589 /* same input source, not update */
8590 if ( g_AudioVars2->eMainSourceType == eSourceType )
8591 {
8592 return;
8593 }
8594
8595 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
8596
8597 HALAUDIO_PRINT ("%s: PrevSource %d NowSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType, eSourceType);
8598
8599 /* release prev DSP resource */
8600 if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN && eSourceType != E_AUDIO_INFO_DTV_IN) )
8601 {
8602 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = FALSE;
8603 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8604 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_NONE;
8605 HALAUDIO_PRINT ("%s: Release DEC DSP from DTV !!\r\n", __FUNCTION__);
8606 }
8607 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN && eSourceType != E_AUDIO_INFO_ATV_IN) )
8608 {
8609 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8610 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8611 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8612 HALAUDIO_PRINT ("%s: Release SND DSP from ATV !!\r\n", __FUNCTION__);
8613 }
8614 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN && eSourceType != E_AUDIO_INFO_HDMI_IN) )
8615 {
8616 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8617 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8618 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8619 HALAUDIO_PRINT ("%s: Release SND DSP from HDMI !!\r\n", __FUNCTION__);
8620 }
8621
8622 g_AudioVars2->ePrevSourceType = g_AudioVars2->eMainSourceType;
8623 g_AudioVars2->eMainSourceType = eSourceType;
8624
8625 /* lock main input source DSP resource */
8626 if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN )
8627 {
8628 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = TRUE;
8629 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8630 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_DTV;
8631 HALAUDIO_PRINT ("%s: Alloc DEC DSP for DTV !!\r\n", __FUNCTION__);
8632 }
8633 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN )
8634 {
8635 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8636 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8637 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_ATV;
8638 HALAUDIO_PRINT ("%s: Alloc DEC DSP for ATV !!\r\n", __FUNCTION__);
8639 }
8640 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN )
8641 {
8642 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8643 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8644 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_HDMI;
8645 HALAUDIO_PRINT ("%s: Alloc DEC DSP for HDMI !!\r\n", __FUNCTION__);
8646 }
8647
8648 HALAUDIO_PRINT ("%s: update PrevSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType);
8649
8650 OS_RELEASE_MUTEX(_s32MutexLoadCode);
8651 }
8652
HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id)8653 Audio_id HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id) //temp
8654 {
8655 Audio_id ADEC_id;
8656 switch(dec_id)
8657 {
8658 case AU_DEC_INVALID:
8659 case AU_DEC_MAX:
8660 printf("[Error] Can't convert...\n");
8661 ADEC_id = ADEC1; //no usage just take one for it...
8662 break;
8663
8664 case AU_DEC_ID1:
8665 ADEC_id = ADEC1;
8666 break;
8667
8668 case AU_DEC_ID2:
8669 case AU_DEC_ID3:
8670 ADEC_id = ADEC2;
8671 break;
8672
8673 default:
8674 ADEC_id = ADEC1;
8675 break;
8676 }
8677 return ADEC_id;
8678 }
8679
8680 ////////////////////////////////////////////////////////////////////////////////
8681 /// @brief \b Function \b Name: HAL_AUDIO_GetCaps()
8682 /// @brief \b Function \b Description: Get Audio Capabilities
8683 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
8684 /// @param <IN> \b MS_U32 * : Audio Capabilites pointer
8685 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
8686 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId,MS_U32 * pCaps)8687 MS_U32 HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId, MS_U32 *pCaps)
8688 {
8689 AUDIO_CAPABILITIES *pCapsTmp = NULL;
8690 MS_U32 u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
8691
8692 HALAUDIO_CHECK_SHM_INIT;
8693
8694 if (pCaps == NULL)
8695 {
8696 HALAUDIO_ERROR("%s: Error! pCaps should not be NULL!\n", __FUNCTION__);
8697 return FALSE;
8698 }
8699
8700 if ((DecId <= AU_DEC_INVALID) || (DecId >= AU_DEC_MAX) || (DecId == AU_DEC_ID2))
8701 {
8702 HALAUDIO_ERROR("%s: Error! Invalid DecId (%d)!\n", __FUNCTION__, DecId);
8703 return FALSE;
8704 }
8705 else if ((g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum == 1) && (DecId > AU_DEC_ID1))
8706 {
8707 HALAUDIO_ERROR("%s: Error! DecId (%d) is greater than max decoder number (%d)!\n", __FUNCTION__, DecId, g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum);
8708 return FALSE;
8709 }
8710
8711 pCapsTmp = (AUDIO_CAPABILITIES *)pCaps;
8712
8713 if (pCapsTmp->u32AudioCapsVersion == 0)
8714 {
8715 #if defined (CONFIG_UTOPIA_ANDROID_L)
8716 HALAUDIO_ERROR("%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsVersion);
8717 #else
8718 HALAUDIO_ERROR("%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion);
8719 #endif
8720 return FALSE;
8721 }
8722
8723 if (pCapsTmp->u32AudioCapsStructSize == 0)
8724 {
8725 #if defined (CONFIG_UTOPIA_ANDROID_L)
8726 HALAUDIO_ERROR("%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsStructSize);
8727 #else
8728 HALAUDIO_ERROR("%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsStructSize);
8729 #endif
8730 return FALSE;
8731 }
8732
8733 if (pCapsTmp->u32AudioCapsVersion != g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion)
8734 {
8735 #if defined (CONFIG_UTOPIA_ANDROID_L)
8736 HALAUDIO_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);
8737 #else
8738 HALAUDIO_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);
8739 #endif
8740
8741 u32AudioCapsStructSize = (u32AudioCapsStructSize <= pCapsTmp->u32AudioCapsStructSize) ? u32AudioCapsStructSize : pCapsTmp->u32AudioCapsStructSize;
8742 }
8743
8744 memcpy((void *)pCapsTmp, (void *)&g_AudioVars2->AudioCaps[DecId], u32AudioCapsStructSize);
8745
8746 return TRUE;
8747 }
8748
8749 ////////////////////////////////////////////////////////////////////////////////
8750 /// @brief \b Function \b Name: HAL_AUDIO_SET_IPAUTH()
8751 /// @brief \b Function \b Description: HAL_AUDIO_SET_IPAUTH register
8752 /// @param <IN> \b MS_U32 ip_auth
8753 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)8754 void HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)
8755 {
8756 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_ipSecurity, ip_auth);
8757 }
8758
8759 ////////////////////////////////////////////////////////////////////////////////
8760 /// @brief \b Function \b Name: HAL_AUDIO_Set_DecimationMode()
8761 /// @brief \b Function \b Description: HAL_AUDIO_Set_Decimation register
8762 /// @param <IN> \b AUDIO_OUTPUT_TYPE Output_Type: Audio Output type
8763 /// @param <IN> \b MS_BOOL Enable : Audio ID: ADEC ID
8764 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type,Audio_id ID)8765 void HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type, Audio_id ID)
8766 {
8767 switch(Output_Type)
8768 {
8769 case AUDIO_HDMI_OUTPUT: //high rate nonPCM application need decimation
8770 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) &&
8771 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20))
8772 {
8773 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x04);
8774 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x10);
8775 }
8776 else
8777 {
8778 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x00);
8779 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x00);
8780 }
8781 break;
8782
8783 case AUDIO_HDMI_ARC_OUTPUT:
8784 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) &&
8785 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8786 {
8787 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x02);
8788 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x08);
8789 }
8790 else
8791 {
8792 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x00);
8793 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x00);
8794 }
8795 break;
8796
8797 case AUDIO_SPDIF_OUTPUT:
8798 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ID) > 48000) &&
8799 (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8800 {
8801 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x01);
8802 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x04);
8803 }
8804 else
8805 {
8806 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x00);
8807 //HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x00);
8808 }
8809 break;
8810
8811 default:
8812 break;
8813 }
8814 }
8815
8816 ////////////////////////////////////////////////////////////////////////////////
8817 /// @brief \b Function \b Name: HAL_AUDIO_CheckPlayDone()
8818 /// @brief \b Function \b Description: Check file play done. If file play done, will return TRUE
8819 /// @param <IN> \b NONE :
8820 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8821 /// @param <GLOBAL> \b NONE :
8822 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckPlayDone(void)8823 MS_BOOL HAL_AUDIO_CheckPlayDone(void)
8824 {
8825 if (((HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_okFrmCnt) != 0) ||
8826 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_errFrmCnt) != 0)) &&
8827 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_pcmBuf_currLevel) < AUD_R2_DMA_BURST_BYTES))
8828 {
8829 CheckPlayDoneCnt = CheckPlayDoneCnt + 1;
8830
8831 if (CheckPlayDoneCnt == 3)
8832 {
8833 CheckPlayDoneCnt = 0;
8834 return TRUE;
8835 }
8836 return FALSE;
8837 }
8838 else
8839 {
8840 CheckPlayDoneCnt = 0;
8841 return FALSE;
8842 }
8843 }
8844
8845 ////////////////////////////////////////////////////////////////////////////////
8846 /// @brief \b Function \b Name: HAL_AUDIO_CheckVersionInfo()
8847 /// @brief \b Function \b Description: Check Version info
8848 /// @param <IN> \b NONE :
8849 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8850 /// @param <GLOBAL> \b NONE :
8851 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckVersionInfo(void)8852 MS_BOOL HAL_AUDIO_CheckVersionInfo(void)
8853 {
8854 HALAUDIO_PRINT("\r\n \033[1;32m==========Audio R2 & DSP Version Check==================\033[0m");
8855 HALAUDIO_PRINT("\r\n \033[1;32m DEC-R2:0x%06X \033[0m \r\n", DEC_R2_VERSION);
8856 #if ASND_R2_SUPPORT
8857 HALAUDIO_PRINT("\r\n \033[1;32m SND-R2:%06X \033[0m \r\n", SND_R2_VERSION);
8858 #endif
8859 HALAUDIO_PRINT("\r\n \033[1;32m DSP System:0x%06X \033[0m \r\n", system_version_num);
8860
8861 if(HAL_AUDIO_AbsReadReg(REG_DECR2_VERSION) != DEC_R2_VERSION) // Compare DEC R2 Version with Mail Box
8862 {
8863 HALAUDIO_PRINT("\r\n \033[1;32m Audio DEC-R2 Version Mismatch!!!!!!! \033[0m \r\n");
8864 }
8865 return TRUE;
8866 }
8867
8868 ////////////////////////////////////////////////////////////////////////////////
8869 /// @brief \b Function \b Name: HAL_AUDIO_ConvertInputType2SourceInfo()
8870 /// @brief \b Function \b Description: Convert input type to input source info
8871 /// @param <IN> \b eInputType: Audio input type
8872 /// @param <OUT> \b : Audio input source info
8873 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ConvertInputType2SourceInfo(AUDIO_INPUT_TYPE eInputType)8874 AUDIO_SOURCE_INFO_TYPE HAL_AUDIO_ConvertInputType2SourceInfo(AUDIO_INPUT_TYPE eInputType)
8875 {
8876 AUDIO_SOURCE_INFO_TYPE eSourceInfo = E_AUDIO_INFO_ADC_IN;
8877
8878 switch(eInputType)
8879 {
8880 case AUDIO_DSP1_DVB_INPUT:
8881 case AUDIO_DSP1_DVB1_INPUT:
8882 case AUDIO_DSP2_DVB_INPUT:
8883 case AUDIO_DSP2_DVB1_INPUT:
8884 case AUDIO_DSP3_DVB_INPUT:
8885 case AUDIO_DSP3_DVB1_INPUT:
8886 case AUDIO_DSP4_DVB_INPUT:
8887 eSourceInfo = E_AUDIO_INFO_DTV_IN;
8888 break;
8889
8890 case AUDIO_HDMI_INPUT:
8891 case AUDIO_DSP1_HDMI_INPUT:
8892 case AUDIO_DSP1_HDMIx1_INPUT:
8893 case AUDIO_DSP2_HDMI_INPUT:
8894 case AUDIO_DSP2_HDMIx1_INPUT:
8895 case AUDIO_DSP3_HDMI_INPUT:
8896 case AUDIO_DSP3_HDMIx1_INPUT:
8897 eSourceInfo = E_AUDIO_INFO_HDMI_IN;
8898 break;
8899
8900 case AUDIO_DSP1_SIF_INPUT:
8901 case AUDIO_DSP2_SIF_INPUT:
8902 case AUDIO_DSP3_SIF_INPUT:
8903 case AUDIO_DSP4_SIF_INPUT:
8904 eSourceInfo = E_AUDIO_INFO_ATV_IN;
8905 break;
8906
8907 case AUDIO_AUIN0_INPUT:
8908 case AUDIO_AUIN1_INPUT:
8909 case AUDIO_AUIN2_INPUT:
8910 case AUDIO_AUIN3_INPUT:
8911 case AUDIO_AUIN4_INPUT:
8912 case AUDIO_AUIN5_INPUT:
8913 case AUDIO_AUMIC_INPUT:
8914 case AUDIO_ADC2_AUIN0_INPUT:
8915 case AUDIO_ADC2_AUIN1_INPUT:
8916 case AUDIO_ADC2_AUIN2_INPUT:
8917 case AUDIO_ADC2_AUIN3_INPUT:
8918 case AUDIO_ADC2_AUIN4_INPUT:
8919 case AUDIO_ADC2_AUIN5_INPUT:
8920 case AUDIO_ADC2_AUMIC_INPUT:
8921 eSourceInfo = E_AUDIO_INFO_ADC_IN;
8922 break;
8923
8924 default: break;
8925 }
8926
8927 return eSourceInfo;
8928 }
8929
HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue,MS_U32 * pData)8930 MS_S32 HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue, MS_U32 *pData)
8931 {
8932 return 0;
8933 }
8934
HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue,MS_U32 * pData,MS_U32 u32Count)8935 MS_S32 HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue, MS_U32 *pData, MS_U32 u32Count)
8936 {
8937 MS_U32 u32Loop = 0;
8938 MS_S32 s32Ret = -A_EINVAL;
8939
8940 if (u32Count == 0)
8941 {
8942 return -A_EINVAL;
8943 }
8944
8945 if (pData != NULL)
8946 {
8947 for (u32Loop = 0; u32Loop < u32Count ; u32Loop++)
8948 {
8949 if (pData[u32Loop] == 0)
8950 {
8951 break;
8952 }
8953
8954 if (u32alue == pData[u32Loop])
8955 {
8956 s32Ret = 0;
8957 break;
8958 }
8959 }
8960 }
8961 else
8962 {
8963 s32Ret = -A_EFAULT;
8964 }
8965
8966 return s32Ret;
8967 }
8968
8969 #if AUDIO_HW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)8970 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)
8971 {
8972 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8973 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8974 MS_U16 u16Divisor = 0;
8975 MS_U16 u16Synthrate = 0;
8976 MS_U32 u32TargetBufferSize = 0;
8977 MS_U32 u32TargetChannel = 0;
8978 MS_U32 u32TargetBitWidth = 0;
8979 MS_U32 u32TargetAlignmentSize = 0;
8980 MS_S32 s32Ret = 0;
8981
8982 /*
8983 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
8984 */
8985 switch(pPcmInfo->u32SampleRate) {
8986 case 8000:
8987 {
8988 u16Divisor = 2;
8989 u16Synthrate = 0x6978;
8990 break;
8991 }
8992
8993 case 11025:
8994 {
8995 u16Divisor = 2;
8996 u16Synthrate = 0x4C87;
8997 break;
8998 }
8999
9000 case 12000:
9001 {
9002 u16Divisor = 2;
9003 u16Synthrate = 0x4650;
9004 break;
9005 }
9006
9007 case 16000:
9008 {
9009 u16Divisor = 1;
9010 u16Synthrate = 0x6978;
9011 break;
9012 }
9013
9014 case 22050:
9015 {
9016 u16Divisor = 1;
9017 u16Synthrate = 0x4C87;
9018 break;
9019 }
9020
9021 case 24000:
9022 {
9023 u16Divisor = 1;
9024 u16Synthrate = 0x4650;
9025 break;
9026 }
9027
9028 case 32000:
9029 {
9030 u16Divisor = 0;
9031 u16Synthrate = 0x6978;
9032 break;
9033 }
9034
9035 case 44100:
9036 {
9037 u16Divisor = 0;
9038 u16Synthrate = 0x4C87;
9039 break;
9040 }
9041
9042 case 48000:
9043 {
9044 u16Divisor = 0;
9045 u16Synthrate = 0x4650;
9046 break;
9047 }
9048
9049 default:
9050 {
9051 u16Divisor = 0;
9052 u16Synthrate = 0x4650;
9053 pPcmInfo->u32SampleRate = 48000;
9054 break;
9055 }
9056 }
9057
9058 /* enable DMA synthesizer */
9059 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG0, 0x20, 0x20);
9060
9061 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9062 HAL_AUDIO_WriteMaskReg(REG_AUDIO_CLK_CFG6, 0x6000, (u16Divisor << 13));
9063 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_SYNTH_NF, 0xFFFF, u16Synthrate);
9064
9065 /* calculate buffer size */
9066 u32TargetChannel = 2;
9067 u32TargetBitWidth = 16;
9068 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9069 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9070 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9071 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
9072 {
9073 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);
9074 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
9075 pPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
9076 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
9077 }
9078
9079 /* set buffer size */
9080 u32TargetBufferSize = u32TargetBufferSize * 2; /* for HW DMA Reader specification */
9081 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_3, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9082
9083 /* set overrun & underrun threshold */
9084 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_4, 0xFFFF, u32TargetBufferSize - 12);
9085 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_5, 0xFFFF, 0x0012);
9086
9087 pPCM->u8SettingChangeFlag = FALSE;
9088
9089 return s32Ret;
9090 }
9091
HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)9092 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)
9093 {
9094 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9095 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9096 MS_S32 s32Ret = 0;
9097
9098 if (pPcmInfo->u8ConnectFlag == FALSE)
9099 {
9100 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9101 return -A_EPERM;
9102 }
9103
9104 /* clear PCM buffer */
9105 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
9106
9107 /* flush MIU */
9108 MsOS_FlushMemory();
9109
9110 /* clear engine's write pointer */
9111 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, 0x0000);
9112
9113 /* reset & start engine */
9114 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x6402);
9115 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x2402);
9116
9117 /* reset write pointer */
9118 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9119
9120 /* reset remain size */
9121 pPCM->tPcmBufferInfo.u32RemainSize = 0;
9122
9123 return s32Ret;
9124 }
9125
HAL_AUDIO_PCM_HwDma_Reader1_Open(void * pData)9126 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Open(void *pData)
9127 {
9128 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9129 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9130 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
9131 MS_U32 u32TargetBufferAddrPa = 0;
9132 MS_U32 u32TargetBufferSize = 0;
9133 MS_U32 u32TargetChannel = 0;
9134 MS_U32 u32TargetBitWidth = 0;
9135 MS_U32 u32TargetAlignmentSize = 0;
9136 MS_S32 s32Ret = 0;
9137 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
9138
9139 if (pData == NULL)
9140 {
9141 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9142 return -A_EFAULT;
9143 }
9144
9145 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9146
9147 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9148 {
9149 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);
9150 return -A_EINVAL;
9151 }
9152
9153 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9154 {
9155 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
9156 return -A_EINVAL;
9157 }
9158
9159 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9160 {
9161 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9162 return -A_EINVAL;
9163 }
9164
9165 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9166 {
9167 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9168 return -A_EINVAL;
9169 }
9170
9171 if (pUserPcmInfo->u8CaptureFlag == TRUE)
9172 {
9173 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
9174 return -A_EINVAL;
9175 }
9176
9177 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)
9178 {
9179 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
9180 return -A_EINVAL;
9181 }
9182
9183 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)
9184 {
9185 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
9186 return -A_EINVAL;
9187 }
9188
9189 /* calculate buffer size */
9190 u32TargetChannel = 2;
9191 u32TargetBitWidth = 16;
9192 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9193 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9194 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9195 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
9196 {
9197 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);
9198 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
9199 pUserPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
9200 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
9201 }
9202
9203 /* fill in settings */
9204 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9205 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
9206 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
9207 pPcmInfo->u8ConnectFlag = TRUE;
9208 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9209 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9210 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
9211 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
9212 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
9213 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
9214 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
9215 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
9216 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
9217 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
9218 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
9219 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
9220
9221 /* init PCM buffer address */
9222 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR;
9223 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
9224 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
9225 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9226
9227 /* set PCM buffer address */
9228 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DMA_RD_CTRL_7, 0xFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFF)); /* RD_BASE_ADDR[7:0] */
9229 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_2, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 8) & 0xFFFF)); /* RD_BASE_ADDR[23:8] */
9230 HAL_AUDIO_WriteMaskByte((REG_AUDIO_DMA_RD_CTRL_7 + 1), 0x0F, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 24) & 0x0F)); /* RD_BASE_ADDR[27:24] */
9231
9232 /* set SEL_CLK_DMA_READER */
9233 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG6, 0x07, 0x04);
9234
9235 /* apply setting */
9236 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
9237
9238 /* restart */
9239 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9240
9241 /* TODO : force channel8 to HW DMA Reader1, it's a hardcode */
9242 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04);
9243 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F);
9244
9245 return s32Ret;
9246 }
9247
HAL_AUDIO_PCM_HwDma_Reader1_Close(void)9248 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Close(void)
9249 {
9250 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9251 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9252 MS_S32 s32Ret = 0;
9253 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
9254
9255 if (pPcmInfo->u8ConnectFlag != FALSE)
9256 {
9257 HAL_AUDIO_PCM_HwDma_Reader1_Flush();
9258 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9259 }
9260
9261 return s32Ret;
9262 }
9263
HAL_AUDIO_PCM_HwDma_Reader1_Start(void)9264 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Start(void)
9265 {
9266 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9267 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9268 MS_S32 s32Ret = 0;
9269 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
9270
9271 if (pPcmInfo->u8StartFlag == FALSE)
9272 {
9273 if (pPCM->u8SettingChangeFlag == TRUE)
9274 {
9275 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
9276 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9277 }
9278
9279 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0001);
9280 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0100);
9281
9282 pPcmInfo->u8StartFlag = TRUE;
9283 }
9284
9285 return s32Ret;
9286 }
9287
HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)9288 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)
9289 {
9290 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9291 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9292 MS_S32 s32Ret = 0;
9293 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
9294
9295 if (pPcmInfo->u8StartFlag != FALSE)
9296 {
9297 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0000);
9298 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0000);
9299
9300 pPcmInfo->u8StartFlag = FALSE;
9301 }
9302
9303 return s32Ret;
9304 }
9305
HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)9306 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
9307 {
9308 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9309 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9310 MS_S32 s32Ret = 0;
9311 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9312
9313 if (pData == NULL)
9314 {
9315 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9316 return -A_EFAULT;
9317 }
9318
9319 if (pPcmInfo->u8ConnectFlag == FALSE)
9320 {
9321 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9322 return -A_EPERM;
9323 }
9324
9325 switch(u32Cmd)
9326 {
9327 case AUDIO_PCM_CMD_NONBLOCKING:
9328 {
9329 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
9330
9331 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
9332 {
9333 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
9334 s32Ret = -A_EINVAL;
9335 break;
9336 }
9337
9338 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
9339
9340 break;
9341 }
9342
9343 case AUDIO_PCM_CMD_MULTICH:
9344 {
9345 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
9346
9347 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
9348 {
9349 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
9350 s32Ret = -A_EINVAL;
9351 break;
9352 }
9353
9354 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9355 {
9356 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9357 s32Ret = -A_EINVAL;
9358 break;
9359 }
9360
9361 pPcmInfo->u8MultiChFlag = FALSE;
9362
9363 break;
9364 }
9365
9366 case AUDIO_PCM_CMD_MIXING:
9367 {
9368 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
9369
9370 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
9371 {
9372 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
9373 s32Ret = -A_EINVAL;
9374 break;
9375 }
9376
9377 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9378 {
9379 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9380 s32Ret = -A_EINVAL;
9381 break;
9382 }
9383
9384 pPcmInfo->u8MixingFlag = FALSE;
9385
9386 break;
9387 }
9388
9389 case AUDIO_PCM_CMD_MIXINGGROUP:
9390 {
9391 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
9392
9393 pPcmInfo->u32MixingGroup = u32MixingGroup;
9394
9395 break;
9396 }
9397
9398 case AUDIO_PCM_CMD_BUFFERDURATION:
9399 {
9400 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
9401
9402 if (u32BufferDuration == 0)
9403 {
9404 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
9405 s32Ret = -A_EINVAL;
9406 break;
9407 }
9408
9409 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
9410 {
9411 pPcmInfo->u32BufferDuration = u32BufferDuration;
9412 pPCM->u8SettingChangeFlag = TRUE;
9413 }
9414
9415 break;
9416 }
9417
9418 case AUDIO_PCM_CMD_CHANNEL:
9419 {
9420 MS_U32 u32Channel = *((MS_U32 *)pData);
9421
9422 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9423 {
9424 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
9425 return -A_EINVAL;
9426 }
9427
9428 pPcmInfo->u32Channel = u32Channel;
9429
9430 break;
9431 }
9432
9433 case AUDIO_PCM_CMD_SAMPLERATE:
9434 {
9435 MS_U32 u32SampleRate = *((MS_U32 *)pData);
9436
9437 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9438 {
9439 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
9440 return -A_EINVAL;
9441 }
9442
9443 if (pPcmInfo->u32SampleRate != u32SampleRate)
9444 {
9445 pPcmInfo->u32SampleRate = u32SampleRate;
9446 pPCM->u8SettingChangeFlag = TRUE;
9447 }
9448
9449 break;
9450 }
9451
9452 case AUDIO_PCM_CMD_BITWIDTH:
9453 {
9454 MS_U32 u32BitWidth = *((MS_U32 *)pData);
9455
9456 pPcmInfo->u32BitWidth = u32BitWidth;
9457
9458 break;
9459 }
9460
9461 case AUDIO_PCM_CMD_BIGENDIAN:
9462 {
9463 MS_U32 u32BigEndian = *((MS_U32 *)pData);
9464
9465 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
9466 {
9467 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
9468 return -A_EINVAL;
9469 }
9470
9471 pPcmInfo->u32BigEndian = u32BigEndian;
9472
9473 break;
9474 }
9475
9476 case AUDIO_PCM_CMD_TIMESTAMP:
9477 {
9478 MS_U32 u32Timestamp = *((MS_U32 *)pData);
9479
9480 pPcmInfo->u32Timestamp = u32Timestamp;
9481
9482 break;
9483 }
9484
9485 case AUDIO_PCM_CMD_WEIGHTING:
9486 {
9487 MS_U32 u32Weighting = *((MS_U32 *)pData);
9488
9489 if (u32Weighting > 100)
9490 {
9491 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
9492 return -A_EINVAL;
9493 }
9494
9495 pPcmInfo->u32Weighting = u32Weighting;
9496
9497 break;
9498 }
9499
9500 case AUDIO_PCM_CMD_VOLUME:
9501 {
9502 MS_U32 u32Volume = *((MS_U32 *)pData);
9503
9504 if (u32Volume > 100)
9505 {
9506 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
9507 return -A_EINVAL;
9508 }
9509
9510 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
9511
9512 break;
9513 }
9514
9515 case AUDIO_PCM_CMD_MUTE:
9516 {
9517 MS_U32 u32Mute = *((MS_U32*)pData);
9518
9519 if (u32Mute == TRUE)
9520 {
9521 pPcmInfo->u32Volume |= 0x80000000;
9522 }
9523 else if (u32Mute == FALSE)
9524 {
9525 pPcmInfo->u32Volume &= 0x7FFFFFFF;
9526 }
9527 else
9528 {
9529 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
9530 s32Ret = -A_EINVAL;
9531 }
9532 break;
9533 }
9534
9535 default:
9536 {
9537 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9538 break;
9539 }
9540 }
9541
9542 return s32Ret;
9543 }
9544
HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)9545 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
9546 {
9547 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9548 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9549 MS_S32 s32Ret = 0;
9550 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9551
9552 if (pData == NULL)
9553 {
9554 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9555 return -A_EFAULT;
9556 }
9557
9558 if (pPcmInfo->u8ConnectFlag == FALSE)
9559 {
9560 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9561 return -A_EPERM;
9562 }
9563
9564 switch(u32Cmd)
9565 {
9566 case AUDIO_PCM_CMD_ALL:
9567 {
9568 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9569 MS_U32 u32MinSize = 0;
9570
9571 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9572 {
9573 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);
9574 s32Ret = -A_EINVAL;
9575 break;
9576 }
9577 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
9578 {
9579 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);
9580 }
9581
9582 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
9583 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
9584 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
9585
9586 break;
9587 }
9588
9589 case AUDIO_PCM_CMD_NONBLOCKING:
9590 {
9591 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9592 break;
9593 }
9594
9595 case AUDIO_PCM_CMD_MULTICH:
9596 {
9597 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9598 break;
9599 }
9600
9601 case AUDIO_PCM_CMD_MIXING:
9602 {
9603 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9604 break;
9605 }
9606
9607 case AUDIO_PCM_CMD_MIXINGGROUP:
9608 {
9609 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9610 break;
9611 }
9612
9613 case AUDIO_PCM_CMD_BUFFER:
9614 {
9615 /*
9616 * TODO, need better coding
9617 *
9618 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
9619 */
9620 break;
9621 }
9622
9623 case AUDIO_PCM_CMD_BUFFERDURATION:
9624 {
9625 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9626 break;
9627 }
9628
9629 case AUDIO_PCM_CMD_READPTR:
9630 {
9631 /*
9632 * TODO, need better coding
9633 *
9634 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
9635 */
9636 break;
9637 }
9638
9639 case AUDIO_PCM_CMD_WRITEPTR:
9640 {
9641 /*
9642 * TODO, need better coding
9643 *
9644 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
9645 */
9646 break;
9647 }
9648
9649 case AUDIO_PCM_CMD_CHANNEL:
9650 {
9651 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9652 break;
9653 }
9654
9655 case AUDIO_PCM_CMD_SAMPLERATE:
9656 {
9657 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9658 break;
9659 }
9660
9661 case AUDIO_PCM_CMD_BITWIDTH:
9662 {
9663 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
9664 break;
9665 }
9666
9667 case AUDIO_PCM_CMD_BIGENDIAN:
9668 {
9669 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
9670 break;
9671 }
9672
9673 case AUDIO_PCM_CMD_TIMESTAMP:
9674 {
9675 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
9676 break;
9677 }
9678
9679 case AUDIO_PCM_CMD_WEIGHTING:
9680 {
9681 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
9682 break;
9683 }
9684
9685 case AUDIO_PCM_CMD_VOLUME:
9686 {
9687 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
9688 break;
9689 }
9690
9691 case AUDIO_PCM_CMD_BUFFERLEVEL:
9692 {
9693 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0010);
9694 pPcmInfo->u32BufferLevel = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_6) * BYTES_IN_MIU_LINE) / 2;
9695 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0000);
9696 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
9697 break;
9698 }
9699
9700 case AUDIO_PCM_CMD_MUTE:
9701 {
9702 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
9703 break;
9704 }
9705
9706 case AUDIO_PCM_CMD_BUFFERSIZE:
9707 {
9708 *((MS_U32 *)pData) = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_3) * BYTES_IN_MIU_LINE) / 2; /* return valid size */
9709 break;
9710 }
9711
9712 default:
9713 {
9714 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9715 break;
9716 }
9717 }
9718
9719 return s32Ret;
9720 }
9721
HAL_AUDIO_PCM_HwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)9722 MS_U32 HAL_AUDIO_PCM_HwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
9723 {
9724 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9725 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9726 MS_S8 *pBufTmp = NULL;
9727 MS_U32 u32BufferSize = 0;
9728 MS_U32 u32PcmLevel = 0;
9729 MS_U32 u32RequestSize = 0;
9730 MS_U32 u32RequestSampleCount = 0;
9731 MS_U32 u32Loop = 0;
9732 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
9733
9734 if (pBuf == NULL)
9735 {
9736 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
9737 return 0;
9738 }
9739
9740 if (u32Size == 0)
9741 {
9742 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
9743 return 0;
9744 }
9745
9746 if (pPcmInfo->u8ConnectFlag == FALSE)
9747 {
9748 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9749 return 0;
9750 }
9751
9752 if (pPcmInfo->u8StartFlag == FALSE)
9753 {
9754 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
9755 return 0;
9756 }
9757
9758 pBufTmp = (MS_S8 *)pBuf;
9759
9760 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
9761 u32PcmLevel = u32PcmLevel * 2;
9762 if ((u32PcmLevel / BYTES_IN_MIU_LINE) <= 6)
9763 {
9764 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
9765
9766 u32PcmLevel = 0;
9767 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9768 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9769 HAL_AUDIO_PCM_HwDma_Reader1_Start();
9770 }
9771
9772 u32RequestSize = u32Size * 2;
9773 u32RequestSampleCount = u32Size / 2;
9774
9775 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
9776 u32BufferSize = u32BufferSize * 2;
9777
9778 /* copy data to PCM buffer */
9779 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
9780 {
9781 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
9782 {
9783 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9784 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L low, R low, L low, R low, ... */
9785 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L high, R high, L high, R high, ... */
9786 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9787
9788 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9789 {
9790 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9791 {
9792 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
9793 }
9794 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9795 }
9796 }
9797
9798 /* flush MIU */
9799 MsOS_FlushMemory();
9800
9801 /* update copied size to engine */
9802 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
9803 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, (u32RequestSize/BYTES_IN_MIU_LINE));
9804 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
9805 #ifdef MSOS_TYPE_LINUX_KERNEL
9806 udelay(50);
9807 #else
9808 AUDIO_DELAY1US(50);
9809 #endif
9810
9811 return u32Size;
9812 }
9813
9814 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
9815
9816 return 0;
9817 }
9818
HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)9819 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)
9820 {
9821 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9822 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9823 MS_S32 s32Ret = 0;
9824 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
9825
9826 if (pPcmInfo->u8StartFlag == FALSE)
9827 {
9828 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9829 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9830 }
9831
9832 return s32Ret;
9833 }
9834 #endif
9835
9836 #if AUDIO_HW_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)9837 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)
9838 {
9839 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9840 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9841 MS_U16 u16Divisor = 0;
9842 MS_U16 u16Synthrate = 0;
9843 MS_U32 u32TargetBufferSize = 0;
9844 MS_U32 u32TargetChannel = 0;
9845 MS_U32 u32TargetBitWidth = 0;
9846 MS_U32 u32TargetAlignmentSize = 0;
9847 MS_S32 s32Ret = 0;
9848
9849 /*
9850 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
9851 */
9852 switch(pPcmInfo->u32SampleRate) {
9853 case 8000:
9854 {
9855 u16Divisor = 2;
9856 u16Synthrate = 0x6978;
9857 break;
9858 }
9859
9860 case 11025:
9861 {
9862 u16Divisor = 2;
9863 u16Synthrate = 0x4C87;
9864 break;
9865 }
9866
9867 case 12000:
9868 {
9869 u16Divisor = 2;
9870 u16Synthrate = 0x4650;
9871 break;
9872 }
9873
9874 case 16000:
9875 {
9876 u16Divisor = 1;
9877 u16Synthrate = 0x6978;
9878 break;
9879 }
9880
9881 case 22050:
9882 {
9883 u16Divisor = 1;
9884 u16Synthrate = 0x4C87;
9885 break;
9886 }
9887
9888 case 24000:
9889 {
9890 u16Divisor = 1;
9891 u16Synthrate = 0x4650;
9892 break;
9893 }
9894
9895 case 32000:
9896 {
9897 u16Divisor = 0;
9898 u16Synthrate = 0x6978;
9899 break;
9900 }
9901
9902 case 44100:
9903 {
9904 u16Divisor = 0;
9905 u16Synthrate = 0x4C87;
9906 break;
9907 }
9908
9909 case 48000:
9910 {
9911 u16Divisor = 0;
9912 u16Synthrate = 0x4650;
9913 break;
9914 }
9915
9916 default:
9917 {
9918 u16Divisor = 0;
9919 u16Synthrate = 0x4650;
9920 pPcmInfo->u32SampleRate = 48000;
9921 break;
9922 }
9923 }
9924
9925 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9926 HAL_AUDIO_AbsWriteReg(NewDMAreader_ctrl, 0x0000);
9927 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0030, (u16Divisor << 4));
9928 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Syth, 0xFFFF, u16Synthrate);
9929
9930 /* enable DMA synthesizer */
9931 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0145, 0x0145);
9932
9933 /* calculate buffer size */
9934 u32TargetChannel = 2;
9935 u32TargetBitWidth = 16;
9936 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9937 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9938 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9939 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9940 {
9941 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);
9942 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9943 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
9944 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
9945 }
9946
9947 /* set buffer size */
9948 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9949
9950 /* set overrun & underrun threshold */
9951 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x0012);
9952
9953 pPCM->u8SettingChangeFlag = FALSE;
9954
9955 return s32Ret;
9956 }
9957
HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)9958 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)
9959 {
9960 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9961 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9962 MS_S32 s32Ret = 0;
9963
9964 if (pPcmInfo->u8ConnectFlag == FALSE)
9965 {
9966 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9967 return -A_EPERM;
9968 }
9969
9970 /* clear PCM buffer */
9971 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR2_BUF_SIZE);
9972
9973 /* flush MIU */
9974 MsOS_FlushMemory();
9975
9976 /* clear engine's write pointer */
9977 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, 0x0000);
9978
9979 /* reset & start engine */
9980 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
9981 #ifdef MSOS_TYPE_LINUX_KERNEL
9982 udelay(50);
9983 #else
9984 AUDIO_DELAY1US(50);
9985 #endif
9986 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
9987
9988 /* reset write pointer */
9989 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9990
9991 /* reset remain size */
9992 pPCM->tPcmBufferInfo.u32RemainSize = 0;
9993
9994 return s32Ret;
9995 }
9996
HAL_AUDIO_PCM_HwDma_Reader2_Open(void * pData)9997 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Open(void *pData)
9998 {
9999 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10000 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10001 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10002 MS_U32 u32TargetBufferAddrPa = 0;
10003 MS_U32 u32TargetBufferSize = 0;
10004 MS_U32 u32TargetChannel = 0;
10005 MS_U32 u32TargetBitWidth = 0;
10006 MS_U32 u32TargetAlignmentSize = 0;
10007 MS_S32 s32Ret = 0;
10008 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10009
10010 if (pData == NULL)
10011 {
10012 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10013 return -A_EFAULT;
10014 }
10015
10016 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10017
10018 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10019 {
10020 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);
10021 return -A_EINVAL;
10022 }
10023
10024 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10025 {
10026 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
10027 return -A_EINVAL;
10028 }
10029
10030 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10031 {
10032 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10033 return -A_EINVAL;
10034 }
10035
10036 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10037 {
10038 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10039 return -A_EINVAL;
10040 }
10041
10042 if (pUserPcmInfo->u8CaptureFlag == TRUE)
10043 {
10044 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
10045 return -A_EINVAL;
10046 }
10047
10048 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)
10049 {
10050 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
10051 return -A_EINVAL;
10052 }
10053
10054 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)
10055 {
10056 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
10057 return -A_EINVAL;
10058 }
10059
10060 /* calculate buffer size */
10061 u32TargetChannel = 2;
10062 u32TargetBitWidth = 16;
10063 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10064 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10065 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10066 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
10067 {
10068 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);
10069 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
10070 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10071 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
10072 }
10073
10074 /* fill in settings */
10075 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10076 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10077 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10078 pPcmInfo->u8ConnectFlag = TRUE;
10079 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10080 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10081
10082 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10083 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10084 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10085 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10086 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10087 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10088 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10089 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
10090 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10091 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10092
10093 /* init PCM buffer address */
10094 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR2_BUF_ADDR;
10095 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10096 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
10097 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10098
10099 /* set PCM buffer address */
10100 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Lo, 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* RD_BASE_ADDR[15:0] */
10101 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Hi, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16) & 0xFFFF)); /* RD_BASE_ADDR[31:15] */
10102
10103 /* apply setting */
10104 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
10105
10106 /* restart */
10107 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10108
10109 /* TODO : force channel6 to HW DMA Reader2, it's a hardcode */
10110 //HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x90);
10111
10112 return s32Ret;
10113 }
10114
HAL_AUDIO_PCM_HwDma_Reader2_Close(void)10115 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Close(void)
10116 {
10117 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10118 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10119 MS_S32 s32Ret = 0;
10120 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10121
10122 if (pPcmInfo->u8ConnectFlag != FALSE)
10123 {
10124 HAL_AUDIO_PCM_HwDma_Reader2_Flush();
10125 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10126 }
10127
10128 return s32Ret;
10129 }
10130
HAL_AUDIO_PCM_HwDma_Reader2_Start(void)10131 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Start(void)
10132 {
10133 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10134 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10135 MS_S32 s32Ret = 0;
10136 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10137
10138 if (pPcmInfo->u8StartFlag == FALSE)
10139 {
10140 if (pPCM->u8SettingChangeFlag == TRUE)
10141 {
10142 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
10143 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10144 }
10145
10146 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0001);
10147 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0002);
10148
10149 pPcmInfo->u8StartFlag = TRUE;
10150 }
10151
10152 return s32Ret;
10153 }
10154
HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)10155 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)
10156 {
10157 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10158 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10159 MS_S32 s32Ret = 0;
10160 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10161
10162 if (pPcmInfo->u8StartFlag != FALSE)
10163 {
10164 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0000);
10165 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0000);
10166
10167 pPcmInfo->u8StartFlag = FALSE;
10168 }
10169
10170 return s32Ret;
10171 }
10172
HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd,const void * pData)10173 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
10174 {
10175 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10176 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10177 MS_S32 s32Ret = 0;
10178 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10179
10180 if (pData == NULL)
10181 {
10182 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10183 return -A_EFAULT;
10184 }
10185
10186 if (pPcmInfo->u8ConnectFlag == FALSE)
10187 {
10188 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10189 return -A_EPERM;
10190 }
10191
10192 switch(u32Cmd)
10193 {
10194 case AUDIO_PCM_CMD_NONBLOCKING:
10195 {
10196 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10197
10198 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10199 {
10200 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10201 s32Ret = -A_EINVAL;
10202 break;
10203 }
10204
10205 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10206
10207 break;
10208 }
10209
10210 case AUDIO_PCM_CMD_MULTICH:
10211 {
10212 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10213
10214 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10215 {
10216 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10217 s32Ret = -A_EINVAL;
10218 break;
10219 }
10220
10221 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10222 {
10223 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10224 s32Ret = -A_EINVAL;
10225 break;
10226 }
10227
10228 pPcmInfo->u8MultiChFlag = FALSE;
10229
10230 break;
10231 }
10232
10233 case AUDIO_PCM_CMD_MIXING:
10234 {
10235 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10236
10237 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10238 {
10239 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10240 s32Ret = -A_EINVAL;
10241 break;
10242 }
10243
10244 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10245 {
10246 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10247 s32Ret = -A_EINVAL;
10248 break;
10249 }
10250
10251 pPcmInfo->u8MixingFlag = FALSE;
10252
10253 break;
10254 }
10255
10256 case AUDIO_PCM_CMD_MIXINGGROUP:
10257 {
10258 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10259
10260 pPcmInfo->u32MixingGroup = u32MixingGroup;
10261
10262 break;
10263 }
10264
10265 case AUDIO_PCM_CMD_BUFFERDURATION:
10266 {
10267 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
10268
10269 if (u32BufferDuration == 0)
10270 {
10271 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
10272 s32Ret = -A_EINVAL;
10273 break;
10274 }
10275
10276 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
10277 {
10278 pPcmInfo->u32BufferDuration = u32BufferDuration;
10279 pPCM->u8SettingChangeFlag = TRUE;
10280 }
10281
10282 break;
10283 }
10284
10285 case AUDIO_PCM_CMD_CHANNEL:
10286 {
10287 MS_U32 u32Channel = *((MS_U32 *)pData);
10288
10289 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10290 {
10291 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
10292 return -A_EINVAL;
10293 }
10294
10295 pPcmInfo->u32Channel = u32Channel;
10296
10297 break;
10298 }
10299
10300 case AUDIO_PCM_CMD_SAMPLERATE:
10301 {
10302 MS_U32 u32SampleRate = *((MS_U32 *)pData);
10303
10304 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10305 {
10306 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
10307 return -A_EINVAL;
10308 }
10309
10310 if (pPcmInfo->u32SampleRate != u32SampleRate)
10311 {
10312 pPcmInfo->u32SampleRate = u32SampleRate;
10313 pPCM->u8SettingChangeFlag = TRUE;
10314 }
10315
10316 break;
10317 }
10318
10319 case AUDIO_PCM_CMD_BITWIDTH:
10320 {
10321 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10322
10323 pPcmInfo->u32BitWidth = u32BitWidth;
10324
10325 break;
10326 }
10327
10328 case AUDIO_PCM_CMD_BIGENDIAN:
10329 {
10330 MS_U32 u32BigEndian = *((MS_U32 *)pData);
10331
10332 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
10333 {
10334 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
10335 return -A_EINVAL;
10336 }
10337
10338 pPcmInfo->u32BigEndian = u32BigEndian;
10339
10340 break;
10341 }
10342
10343 case AUDIO_PCM_CMD_TIMESTAMP:
10344 {
10345 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10346
10347 pPcmInfo->u32Timestamp = u32Timestamp;
10348
10349 break;
10350 }
10351
10352 case AUDIO_PCM_CMD_WEIGHTING:
10353 {
10354 MS_U32 u32Weighting = *((MS_U32 *)pData);
10355
10356 if (u32Weighting > 100)
10357 {
10358 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
10359 return -A_EINVAL;
10360 }
10361
10362 pPcmInfo->u32Weighting = u32Weighting;
10363
10364 break;
10365 }
10366
10367 case AUDIO_PCM_CMD_VOLUME:
10368 {
10369 MS_U32 u32Volume = *((MS_U32 *)pData);
10370
10371 if (u32Volume > 100)
10372 {
10373 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
10374 return -A_EINVAL;
10375 }
10376
10377 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
10378
10379 break;
10380 }
10381
10382 case AUDIO_PCM_CMD_MUTE:
10383 {
10384 MS_U32 u32Mute = *((MS_U32*)pData);
10385
10386 if (u32Mute == TRUE)
10387 {
10388 pPcmInfo->u32Volume |= 0x80000000;
10389 }
10390 else if (u32Mute == FALSE)
10391 {
10392 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10393 }
10394 else
10395 {
10396 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
10397 s32Ret = -A_EINVAL;
10398 }
10399 break;
10400 }
10401
10402 default:
10403 {
10404 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10405 break;
10406 }
10407 }
10408
10409 return s32Ret;
10410 }
10411
HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd,void * pData)10412 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd, void *pData)
10413 {
10414 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10415 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10416 MS_S32 s32Ret = 0;
10417 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10418
10419 if (pData == NULL)
10420 {
10421 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10422 return -A_EFAULT;
10423 }
10424
10425 if (pPcmInfo->u8ConnectFlag == FALSE)
10426 {
10427 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10428 return -A_EPERM;
10429 }
10430
10431 switch(u32Cmd)
10432 {
10433 case AUDIO_PCM_CMD_ALL:
10434 {
10435 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10436 MS_U32 u32MinSize = 0;
10437
10438 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10439 {
10440 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);
10441 s32Ret = -A_EINVAL;
10442 break;
10443 }
10444 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
10445 {
10446 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);
10447 }
10448
10449 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
10450 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
10451 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
10452
10453 break;
10454 }
10455
10456 case AUDIO_PCM_CMD_NONBLOCKING:
10457 {
10458 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
10459 break;
10460 }
10461
10462 case AUDIO_PCM_CMD_MULTICH:
10463 {
10464 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
10465 break;
10466 }
10467
10468 case AUDIO_PCM_CMD_MIXING:
10469 {
10470 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
10471 break;
10472 }
10473
10474 case AUDIO_PCM_CMD_MIXINGGROUP:
10475 {
10476 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
10477 break;
10478 }
10479
10480 case AUDIO_PCM_CMD_BUFFER:
10481 {
10482 /*
10483 * TODO, need better coding
10484 *
10485 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
10486 */
10487 break;
10488 }
10489
10490 case AUDIO_PCM_CMD_BUFFERDURATION:
10491 {
10492 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
10493 break;
10494 }
10495
10496 case AUDIO_PCM_CMD_READPTR:
10497 {
10498 /*
10499 * TODO, need better coding
10500 *
10501 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
10502 */
10503 break;
10504 }
10505
10506 case AUDIO_PCM_CMD_WRITEPTR:
10507 {
10508 /*
10509 * TODO, need better coding
10510 *
10511 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
10512 */
10513 break;
10514 }
10515
10516 case AUDIO_PCM_CMD_CHANNEL:
10517 {
10518 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
10519 break;
10520 }
10521
10522 case AUDIO_PCM_CMD_SAMPLERATE:
10523 {
10524 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
10525 break;
10526 }
10527
10528 case AUDIO_PCM_CMD_BITWIDTH:
10529 {
10530 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10531 break;
10532 }
10533
10534 case AUDIO_PCM_CMD_BIGENDIAN:
10535 {
10536 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10537 break;
10538 }
10539
10540 case AUDIO_PCM_CMD_TIMESTAMP:
10541 {
10542 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10543 break;
10544 }
10545
10546 case AUDIO_PCM_CMD_WEIGHTING:
10547 {
10548 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10549 break;
10550 }
10551
10552 case AUDIO_PCM_CMD_VOLUME:
10553 {
10554 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10555 break;
10556 }
10557
10558 case AUDIO_PCM_CMD_BUFFERLEVEL:
10559 {
10560 MS_U32 u32BufferLevel1 = 0;
10561 MS_U32 u32BufferLevel2 = 0;
10562 MS_U32 u32Timeout = 20;
10563
10564 while (u32Timeout > 0)
10565 {
10566 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0020);
10567 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10568 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10569 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0000);
10570
10571 if (u32BufferLevel1 == u32BufferLevel2)
10572 {
10573 break;
10574 }
10575
10576 u32Timeout--;
10577
10578 #ifdef MSOS_TYPE_LINUX_KERNEL
10579 udelay(1);
10580 #else
10581 AUDIO_DELAY1US(1);
10582 #endif
10583 }
10584
10585 if (u32BufferLevel1 != u32BufferLevel2)
10586 {
10587 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
10588 }
10589
10590 pPcmInfo->u32BufferLevel = u32BufferLevel2;
10591 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10592
10593 break;
10594 }
10595
10596 case AUDIO_PCM_CMD_MUTE:
10597 {
10598 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10599 break;
10600 }
10601
10602 case AUDIO_PCM_CMD_BUFFERSIZE:
10603 {
10604 *((MS_U32 *)pData) = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_size) * BYTES_IN_MIU_LINE;
10605 break;
10606 }
10607
10608 default:
10609 {
10610 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10611 break;
10612 }
10613 }
10614
10615 return s32Ret;
10616 }
10617
HAL_AUDIO_PCM_HwDma_Reader2_Write(const void * pBuf,MS_U32 u32Size)10618 MS_U32 HAL_AUDIO_PCM_HwDma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
10619 {
10620 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10621 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10622 MS_S8 *pBufTmp = NULL;
10623 MS_U32 u32BufferSize = 0;
10624 MS_U32 u32PcmLevel = 0;
10625 MS_U32 u32RequestSize = 0;
10626 MS_U32 u32RequestSizeTmp = 0;
10627 MS_U32 u32SizeToCopy = 0;
10628 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10629
10630 if (pBuf == NULL)
10631 {
10632 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10633 return 0;
10634 }
10635
10636 if (u32Size == 0)
10637 {
10638 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
10639 return 0;
10640 }
10641
10642 if (pPcmInfo->u8ConnectFlag == FALSE)
10643 {
10644 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10645 return 0;
10646 }
10647
10648 if (pPcmInfo->u8StartFlag == FALSE)
10649 {
10650 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
10651 return 0;
10652 }
10653
10654 pBufTmp = (MS_S8 *)pBuf;
10655
10656 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10657 if (u32PcmLevel == 0)
10658 {
10659 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10660 }
10661
10662 u32RequestSize = u32Size;
10663 u32RequestSizeTmp = u32RequestSize;
10664
10665 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
10666
10667 /* copy data to PCM buffer */
10668 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
10669 {
10670 do {
10671 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
10672 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
10673
10674 #ifdef MSOS_TYPE_LINUX_KERNEL
10675 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10676 #else
10677 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10678 #endif
10679
10680 pBufTmp += u32SizeToCopy;
10681 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
10682 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10683 {
10684 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10685 {
10686 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
10687 }
10688 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10689 }
10690
10691 u32RequestSizeTmp -= u32SizeToCopy;
10692 } while (u32RequestSizeTmp > 0);
10693
10694 /* flush MIU */
10695 MsOS_FlushMemory();
10696
10697 /* update copied size to engine */
10698 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
10699 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0000);
10700 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
10701 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0010);
10702 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
10703
10704 return u32Size;
10705 }
10706
10707 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
10708
10709 return 0;
10710 }
10711
HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)10712 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)
10713 {
10714 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10715 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10716 MS_S32 s32Ret = 0;
10717 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
10718
10719 if (pPcmInfo->u8StartFlag == FALSE)
10720 {
10721 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10722 HAL_AUDIO_PCM_HwDma_Reader2_Stop();
10723 }
10724
10725 return s32Ret;
10726 }
10727 #endif
10728
10729 #if AUDIO_SW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)10730 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)
10731 {
10732 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10733 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10734 MS_U16 u16Synthrate_H = 0;
10735 MS_U16 u16Synthrate_L = 0;
10736 MS_U32 u32TargetBufferSize = 0;
10737 MS_U32 u32TargetChannel = 0;
10738 MS_U32 u32TargetBitWidth = 0;
10739 MS_U32 u32TargetAlignmentSize = 0;
10740 MS_S32 s32Ret = 0;
10741
10742 switch(pPcmInfo->u32SampleRate) {
10743 case 8000:
10744 {
10745 u16Synthrate_H = 0x6978;
10746 u16Synthrate_L = 0x0000;
10747 break;
10748 }
10749
10750 case 11025:
10751 {
10752 u16Synthrate_H = 0x4C87;
10753 u16Synthrate_L = 0xD634;
10754 break;
10755 }
10756
10757 case 12000:
10758 {
10759 u16Synthrate_H = 0x4650;
10760 u16Synthrate_L = 0x0000;
10761 break;
10762 }
10763
10764 case 16000:
10765 {
10766 u16Synthrate_H = 0x34BC;
10767 u16Synthrate_L = 0x0000;
10768 break;
10769 }
10770
10771 case 22050:
10772 {
10773 u16Synthrate_H = 0x2643;
10774 u16Synthrate_L = 0xEB1A;
10775 break;
10776 }
10777
10778 case 24000:
10779 {
10780 u16Synthrate_H = 0x2328;
10781 u16Synthrate_L = 0x0000;
10782 break;
10783 }
10784
10785 case 32000:
10786 {
10787 u16Synthrate_H = 0x1A5E;
10788 u16Synthrate_L = 0x0000;
10789 break;
10790 }
10791
10792 case 44100:
10793 {
10794 u16Synthrate_H = 0x1321;
10795 u16Synthrate_L = 0xF58D;
10796 break;
10797 }
10798
10799 case 48000:
10800 {
10801 u16Synthrate_H = 0x1194;
10802 u16Synthrate_L = 0x0000;
10803 break;
10804 }
10805
10806 case 96000:
10807 {
10808 u16Synthrate_H = 0x08CA;
10809 u16Synthrate_L = 0x0000;
10810 break;
10811 }
10812
10813 default:
10814 {
10815 u16Synthrate_H = 0x1194;
10816 u16Synthrate_L = 0x0000;
10817 pPcmInfo->u32SampleRate = 48000;
10818 break;
10819 }
10820 }
10821
10822 /* enable reg_dvb5_fix_synth_nf_h */
10823 HAL_AUDIO_WriteMaskReg(0x2C24, 0xA000, 0xA000);
10824
10825 /* configure sample rate */
10826 HAL_AUDIO_WriteMaskReg(0x2C26, 0xFFFF, u16Synthrate_H);
10827 HAL_AUDIO_WriteMaskReg(0x2C28, 0xFFFF, u16Synthrate_L);
10828
10829 /* trigger reg_dvb5_fix_synth_nf_h to apply configuration */
10830 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x1000);
10831 #ifdef MSOS_TYPE_LINUX_KERNEL
10832 udelay(50);
10833 #else
10834 AUDIO_DELAY1US(50);
10835 #endif
10836 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x0000);
10837
10838 /* calculate buffer size */
10839 u32TargetChannel = 2;
10840 u32TargetBitWidth = 16;
10841 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10842 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10843 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10844 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10845 {
10846 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);
10847 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10848 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10849 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
10850 }
10851
10852 pPCM->u8SettingChangeFlag = FALSE;
10853
10854 return s32Ret;
10855 }
10856
HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)10857 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)
10858 {
10859 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10860 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10861 MS_S32 s32Ret = 0;
10862
10863 if (pPcmInfo->u8ConnectFlag == FALSE)
10864 {
10865 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10866 return -A_EPERM;
10867 }
10868
10869 /* clear PCM buffer */
10870 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, SW_DMA_RDR1_BUF_SIZE);
10871
10872 /* flush MIU */
10873 MsOS_FlushMemory();
10874
10875 /* clear engine's write pointer */
10876 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, 0x0000);
10877
10878 /* reset engine, no start engine here! */
10879 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0001);
10880
10881 /* reset write pointer */
10882 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10883
10884 /* reset remain size */
10885 pPCM->tPcmBufferInfo.u32RemainSize = 0;
10886
10887 return s32Ret;
10888 }
10889
HAL_AUDIO_PCM_SwDma_Reader1_Open(void * pData)10890 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Open(void *pData)
10891 {
10892 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10893 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10894 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10895 MS_U32 u32TargetBufferAddrPa = 0;
10896 MS_U32 u32TargetBufferSize = 0;
10897 MS_U32 u32TargetChannel = 0;
10898 MS_U32 u32TargetBitWidth = 0;
10899 MS_U32 u32TargetAlignmentSize = 0;
10900 MS_S32 s32Ret = 0;
10901 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10902
10903 if (pData == NULL)
10904 {
10905 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10906 return -A_EFAULT;
10907 }
10908
10909 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10910
10911 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10912 {
10913 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);
10914 return -A_EINVAL;
10915 }
10916
10917 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10918 {
10919 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
10920 return -A_EINVAL;
10921 }
10922
10923 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10924 {
10925 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10926 return -A_EINVAL;
10927 }
10928
10929 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10930 {
10931 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10932 return -A_EINVAL;
10933 }
10934
10935 if (pUserPcmInfo->u8CaptureFlag == TRUE)
10936 {
10937 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
10938 return -A_EINVAL;
10939 }
10940
10941 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)
10942 {
10943 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
10944 return -A_EINVAL;
10945 }
10946
10947 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)
10948 {
10949 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
10950 return -A_EINVAL;
10951 }
10952
10953 /* calculate buffer size */
10954 u32TargetChannel = 2;
10955 u32TargetBitWidth = 16;
10956 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10957 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10958 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10959 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10960 {
10961 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);
10962 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10963 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10964 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
10965 }
10966
10967 /* fill in settings */
10968 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10969 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10970 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10971 pPcmInfo->u8ConnectFlag = TRUE;
10972 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10973 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10974 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10975 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10976 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10977 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10978 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10979 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10980 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10981 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
10982 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10983 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10984
10985 /* init PCM buffer address */
10986 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + SW_DMA_RDR1_BUF_ADDR;
10987 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10988 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
10989 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10990
10991 /* apply setting */
10992 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
10993
10994 /* restart */
10995 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
10996
10997 /* TODO : force channel6 to SW DMA Reader, it's a hardcode */
10998 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x8C);
10999
11000 return s32Ret;
11001 }
11002
HAL_AUDIO_PCM_SwDma_Reader1_Close(void)11003 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Close(void)
11004 {
11005 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11006 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11007 MS_S32 s32Ret = 0;
11008 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11009
11010 if (pPcmInfo->u8ConnectFlag != FALSE)
11011 {
11012 HAL_AUDIO_PCM_SwDma_Reader1_Flush();
11013 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11014 }
11015
11016 return s32Ret;
11017 }
11018
HAL_AUDIO_PCM_SwDma_Reader1_Start(void)11019 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Start(void)
11020 {
11021 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11022 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11023 MS_S32 s32Ret = 0;
11024 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11025
11026 if (pPcmInfo->u8StartFlag == FALSE)
11027 {
11028 if (pPCM->u8SettingChangeFlag == TRUE)
11029 {
11030 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
11031 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11032 }
11033
11034 /* start engine */
11035 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0002);
11036
11037 pPcmInfo->u8StartFlag = TRUE;
11038 }
11039
11040 return s32Ret;
11041 }
11042
HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)11043 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)
11044 {
11045 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11046 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11047 MS_S32 s32Ret = 0;
11048 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
11049
11050 if (pPcmInfo->u8StartFlag != FALSE)
11051 {
11052 /* stop engine */
11053 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0000);
11054
11055 pPcmInfo->u8StartFlag = FALSE;
11056 }
11057
11058 return s32Ret;
11059 }
11060
HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)11061 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
11062 {
11063 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11064 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11065 MS_S32 s32Ret = 0;
11066 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11067
11068 if (pData == NULL)
11069 {
11070 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11071 return -A_EFAULT;
11072 }
11073
11074 if (pPcmInfo->u8ConnectFlag == FALSE)
11075 {
11076 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11077 return -A_EPERM;
11078 }
11079
11080 switch(u32Cmd)
11081 {
11082 case AUDIO_PCM_CMD_NONBLOCKING:
11083 {
11084 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
11085
11086 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
11087 {
11088 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
11089 s32Ret = -A_EINVAL;
11090 break;
11091 }
11092
11093 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
11094
11095 break;
11096 }
11097
11098 case AUDIO_PCM_CMD_MULTICH:
11099 {
11100 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
11101
11102 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
11103 {
11104 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
11105 s32Ret = -A_EINVAL;
11106 break;
11107 }
11108
11109 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11110 {
11111 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11112 s32Ret = -A_EINVAL;
11113 break;
11114 }
11115
11116 pPcmInfo->u8MultiChFlag = FALSE;
11117
11118 break;
11119 }
11120
11121 case AUDIO_PCM_CMD_MIXING:
11122 {
11123 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
11124
11125 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
11126 {
11127 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
11128 s32Ret = -A_EINVAL;
11129 break;
11130 }
11131
11132 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11133 {
11134 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11135 s32Ret = -A_EINVAL;
11136 break;
11137 }
11138
11139 pPcmInfo->u8MixingFlag = FALSE;
11140
11141 break;
11142 }
11143
11144 case AUDIO_PCM_CMD_MIXINGGROUP:
11145 {
11146 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
11147
11148 pPcmInfo->u32MixingGroup = u32MixingGroup;
11149
11150 break;
11151 }
11152
11153 case AUDIO_PCM_CMD_BUFFERDURATION:
11154 {
11155 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
11156
11157 if (u32BufferDuration == 0)
11158 {
11159 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
11160 s32Ret = -A_EINVAL;
11161 break;
11162 }
11163
11164 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
11165 {
11166 pPcmInfo->u32BufferDuration = u32BufferDuration;
11167 pPCM->u8SettingChangeFlag = TRUE;
11168 }
11169
11170 break;
11171 }
11172
11173 case AUDIO_PCM_CMD_CHANNEL:
11174 {
11175 MS_U32 u32Channel = *((MS_U32 *)pData);
11176
11177 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11178 {
11179 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
11180 return -A_EINVAL;
11181 }
11182
11183 if (pPcmInfo->u32Channel != u32Channel)
11184 {
11185 pPcmInfo->u32Channel = u32Channel;
11186 pPCM->u8SettingChangeFlag = TRUE;
11187 }
11188
11189 break;
11190 }
11191
11192 case AUDIO_PCM_CMD_SAMPLERATE:
11193 {
11194 MS_U32 u32SampleRate = *((MS_U32 *)pData);
11195
11196 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
11197 {
11198 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
11199 return -A_EINVAL;
11200 }
11201
11202 if (pPcmInfo->u32SampleRate != u32SampleRate)
11203 {
11204 pPcmInfo->u32SampleRate = u32SampleRate;
11205 pPCM->u8SettingChangeFlag = TRUE;
11206 }
11207
11208 break;
11209 }
11210
11211 case AUDIO_PCM_CMD_BITWIDTH:
11212 {
11213 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11214
11215 pPcmInfo->u32BitWidth = u32BitWidth;
11216
11217 break;
11218 }
11219
11220 case AUDIO_PCM_CMD_BIGENDIAN:
11221 {
11222 MS_U32 u32BigEndian = *((MS_U32 *)pData);
11223
11224 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
11225 {
11226 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
11227 return -A_EINVAL;
11228 }
11229
11230 pPcmInfo->u32BigEndian = u32BigEndian;
11231
11232 break;
11233 }
11234
11235 case AUDIO_PCM_CMD_TIMESTAMP:
11236 {
11237 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11238
11239 pPcmInfo->u32Timestamp = u32Timestamp;
11240
11241 break;
11242 }
11243
11244 case AUDIO_PCM_CMD_WEIGHTING:
11245 {
11246 MS_U32 u32Weighting = *((MS_U32 *)pData);
11247
11248 if (u32Weighting > 100)
11249 {
11250 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
11251 return -A_EINVAL;
11252 }
11253
11254 pPcmInfo->u32Weighting = u32Weighting;
11255
11256 break;
11257 }
11258
11259 case AUDIO_PCM_CMD_VOLUME:
11260 {
11261 MS_U32 u32Volume = *((MS_U32 *)pData);
11262
11263 if (u32Volume > 100)
11264 {
11265 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
11266 return -A_EINVAL;
11267 }
11268
11269 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
11270
11271 break;
11272 }
11273
11274 case AUDIO_PCM_CMD_MUTE:
11275 {
11276 MS_U32 u32Mute = *((MS_U32*)pData);
11277
11278 if (u32Mute == TRUE)
11279 {
11280 pPcmInfo->u32Volume |= 0x80000000;
11281 }
11282 else if (u32Mute == FALSE)
11283 {
11284 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11285 }
11286 else
11287 {
11288 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
11289 s32Ret = -A_EINVAL;
11290 }
11291 break;
11292 }
11293
11294 default:
11295 {
11296 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11297 break;
11298 }
11299 }
11300
11301 return s32Ret;
11302 }
11303
HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)11304 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
11305 {
11306 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11307 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11308 MS_S32 s32Ret = 0;
11309 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11310
11311 if (pData == NULL)
11312 {
11313 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11314 return -A_EFAULT;
11315 }
11316
11317 if (pPcmInfo->u8ConnectFlag == FALSE)
11318 {
11319 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11320 return -A_EPERM;
11321 }
11322
11323 switch(u32Cmd)
11324 {
11325 case AUDIO_PCM_CMD_ALL:
11326 {
11327 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11328 MS_U32 u32MinSize = 0;
11329
11330 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11331 {
11332 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);
11333 s32Ret = -A_EINVAL;
11334 break;
11335 }
11336 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
11337 {
11338 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);
11339 }
11340
11341 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
11342 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
11343 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
11344
11345 break;
11346 }
11347
11348 case AUDIO_PCM_CMD_NONBLOCKING:
11349 {
11350 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11351 break;
11352 }
11353
11354 case AUDIO_PCM_CMD_MULTICH:
11355 {
11356 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11357 break;
11358 }
11359
11360 case AUDIO_PCM_CMD_MIXING:
11361 {
11362 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11363 break;
11364 }
11365
11366 case AUDIO_PCM_CMD_MIXINGGROUP:
11367 {
11368 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11369 break;
11370 }
11371
11372 case AUDIO_PCM_CMD_BUFFER:
11373 {
11374 /*
11375 * TODO, need better coding
11376 *
11377 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
11378 */
11379 break;
11380 }
11381
11382 case AUDIO_PCM_CMD_BUFFERDURATION:
11383 {
11384 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11385 break;
11386 }
11387
11388 case AUDIO_PCM_CMD_READPTR:
11389 {
11390 /*
11391 * TODO, need better coding
11392 *
11393 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
11394 */
11395 break;
11396 }
11397
11398 case AUDIO_PCM_CMD_WRITEPTR:
11399 {
11400 /*
11401 * TODO, need better coding
11402 *
11403 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
11404 */
11405 break;
11406 }
11407
11408 case AUDIO_PCM_CMD_CHANNEL:
11409 {
11410 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11411 break;
11412 }
11413
11414 case AUDIO_PCM_CMD_SAMPLERATE:
11415 {
11416 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11417 break;
11418 }
11419
11420 case AUDIO_PCM_CMD_BITWIDTH:
11421 {
11422 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11423 break;
11424 }
11425
11426 case AUDIO_PCM_CMD_BIGENDIAN:
11427 {
11428 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
11429 break;
11430 }
11431
11432 case AUDIO_PCM_CMD_TIMESTAMP:
11433 {
11434 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11435 break;
11436 }
11437
11438 case AUDIO_PCM_CMD_WEIGHTING:
11439 {
11440 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11441 break;
11442 }
11443
11444 case AUDIO_PCM_CMD_VOLUME:
11445 {
11446 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
11447 break;
11448 }
11449
11450 case AUDIO_PCM_CMD_BUFFERLEVEL:
11451 {
11452 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0008);
11453 pPcmInfo->u32BufferLevel = HAL_AUDIO_ReadReg(S2M_MBOX_SW_DMA_READER_DDR_Level) * BYTES_IN_MIU_LINE;
11454 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0000);
11455 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11456 break;
11457 }
11458
11459 case AUDIO_PCM_CMD_MUTE:
11460 {
11461 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11462 break;
11463 }
11464
11465 case AUDIO_PCM_CMD_BUFFERSIZE:
11466 {
11467 MS_U32 u32TargetBufferSize = 0;
11468 MS_U32 u32TargetChannel = 0;
11469 MS_U32 u32TargetBitWidth = 0;
11470
11471 u32TargetChannel = 2;
11472 u32TargetBitWidth = 16;
11473 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11474
11475 *((MS_U32 *)pData) = u32TargetBufferSize;
11476
11477 break;
11478 }
11479
11480 default:
11481 {
11482 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11483 break;
11484 }
11485 }
11486
11487 return s32Ret;
11488 }
11489
HAL_AUDIO_PCM_SwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)11490 MS_U32 HAL_AUDIO_PCM_SwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
11491 {
11492 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11493 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11494 MS_S8 *pBufTmp = NULL;
11495 MS_U32 u32BufferSize = 0;
11496 MS_U32 u32PcmLevel = 0;
11497 MS_U32 u32RequestSize = 0;
11498 MS_U32 u32RequestSizeTmp = 0;
11499 MS_U32 u32SizeToCopy = 0;
11500 MS_U32 u32WptrOffset = 0;
11501 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11502
11503 if (pBuf == NULL)
11504 {
11505 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11506 return 0;
11507 }
11508
11509 if (u32Size == 0)
11510 {
11511 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
11512 return 0;
11513 }
11514
11515 if (pPcmInfo->u8ConnectFlag == FALSE)
11516 {
11517 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11518 return 0;
11519 }
11520
11521 if (pPcmInfo->u8StartFlag == FALSE)
11522 {
11523 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
11524 return 0;
11525 }
11526
11527 pBufTmp = (MS_S8 *)pBuf;
11528
11529 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
11530 if (u32PcmLevel == 0)
11531 {
11532 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11533 }
11534
11535 u32RequestSize = u32Size;
11536 u32RequestSizeTmp = u32RequestSize;
11537
11538 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
11539
11540 /* copy data to PCM buffer */
11541 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
11542 {
11543 do {
11544 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE) - pPCM->tPcmBufferInfo.pWritePtr;
11545 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11546
11547 #ifdef MSOS_TYPE_LINUX_KERNEL
11548 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11549 #else
11550 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11551 #endif
11552
11553 pBufTmp += u32SizeToCopy;
11554 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
11555 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11556 {
11557 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11558 {
11559 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11560 }
11561 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11562 }
11563
11564 u32RequestSizeTmp -= u32SizeToCopy;
11565 } while (u32RequestSizeTmp > 0);
11566
11567 /* flush MIU */
11568 MsOS_FlushMemory();
11569
11570 /* update write pointers to engine */
11571 u32WptrOffset = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pBuffer;
11572 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, (u32WptrOffset / BYTES_IN_MIU_LINE));
11573
11574 return u32Size;
11575 }
11576
11577 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
11578
11579 return 0;
11580 }
11581
HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)11582 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)
11583 {
11584 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11585 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11586 MS_S32 s32Ret = 0;
11587 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
11588
11589 if (pPcmInfo->u8StartFlag == FALSE)
11590 {
11591 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11592 HAL_AUDIO_PCM_SwDma_Reader1_Stop();
11593 }
11594
11595 return s32Ret;
11596 }
11597 #endif
11598
11599 #if AUDIO_R2_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)11600 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)
11601 {
11602 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11603 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11604 MS_U16 u16Val = 0;
11605 MS_U16 u16Synthrate_H = 0;
11606 MS_U16 u16Synthrate_L = 0;
11607 MS_U32 u32TargetBufferSize = 0;
11608 MS_U32 u32TargetChannel = 0;
11609 MS_U32 u32TargetBitWidth = 0;
11610 MS_U32 u32TargetAlignmentSize = 0;
11611 MS_S32 s32Ret = 0;
11612
11613 switch(pPcmInfo->u32SampleRate) {
11614 case 8000:
11615 {
11616 u16Synthrate_H = 0x6978;
11617 u16Synthrate_L = 0x0000;
11618 break;
11619 }
11620
11621 case 11025:
11622 {
11623 u16Synthrate_H = 0x4C87;
11624 u16Synthrate_L = 0xD634;
11625 break;
11626 }
11627
11628 case 12000:
11629 {
11630 u16Synthrate_H = 0x4650;
11631 u16Synthrate_L = 0x0000;
11632 break;
11633 }
11634
11635 case 16000:
11636 {
11637 u16Synthrate_H = 0x34BC;
11638 u16Synthrate_L = 0x0000;
11639 break;
11640 }
11641
11642 case 22050:
11643 {
11644 u16Synthrate_H = 0x2643;
11645 u16Synthrate_L = 0xEB1A;
11646 break;
11647 }
11648
11649 case 24000:
11650 {
11651 u16Synthrate_H = 0x2328;
11652 u16Synthrate_L = 0x0000;
11653 break;
11654 }
11655
11656 case 32000:
11657 {
11658 u16Synthrate_H = 0x1A5E;
11659 u16Synthrate_L = 0x0000;
11660 break;
11661 }
11662
11663 case 44100:
11664 {
11665 u16Synthrate_H = 0x1321;
11666 u16Synthrate_L = 0xF58D;
11667 break;
11668 }
11669
11670 case 48000:
11671 {
11672 u16Synthrate_H = 0x1194;
11673 u16Synthrate_L = 0x0000;
11674 break;
11675 }
11676
11677 case 64000:
11678 {
11679 u16Synthrate_H = 0x0D2F;
11680 u16Synthrate_L = 0x0000;
11681 break;
11682 }
11683
11684 case 88200:
11685 {
11686 u16Synthrate_H = 0x0990;
11687 u16Synthrate_L = 0xFAC6;
11688 break;
11689 }
11690
11691 case 96000:
11692 {
11693 u16Synthrate_H = 0x08CA;
11694 u16Synthrate_L = 0x0000;
11695 break;
11696 }
11697
11698 default:
11699 {
11700 u16Synthrate_H = 0x1194;
11701 u16Synthrate_L = 0x0000;
11702 pPcmInfo->u32SampleRate = 48000;
11703 break;
11704 }
11705 }
11706
11707 /* disable output */
11708 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x7FFF, 0x0000);
11709
11710 /* set synthesizer */
11711 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
11712 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
11713 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11714 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0101); /* SYTH1 bit8RIU control, bit0 update */
11715 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11716
11717 if (pPcmInfo->u8MultiChFlag == TRUE)
11718 {
11719 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11720 u32TargetChannel = 10;
11721 }
11722 else
11723 {
11724 /* stereo = 2 channels */
11725 u32TargetChannel = 2;
11726 }
11727
11728 /* calculate buffer size */
11729 u32TargetBitWidth = 16;
11730 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11731 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11732 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11733 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11734 {
11735 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);
11736 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11737 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11738 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
11739 }
11740
11741 /* set buffer size */
11742 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
11743
11744 /* set overrun & underrun threshold */
11745 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize >> 3)) / BYTES_IN_MIU_LINE));
11746 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
11747
11748 /* set channel mode */
11749 if (pPcmInfo->u8MultiChFlag == TRUE)
11750 {
11751 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11752 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x00);
11753 u16Val = 19; /* MIU burst length = 19 */
11754 u16Val += (1 << 7); /* MIU Step En = 1 */
11755 u16Val += (1 << 15); /* Sync Valid En = 1 */
11756 u16Val += (1 << 8); /* Sync Step Count = 1 */
11757 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11758 }
11759 else
11760 {
11761 /* Stereo mode : stereo = 2 channels */
11762 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x80);
11763 u16Val = 3; /* MIU burst length = 3 */
11764 u16Val += (0 << 7); /* MIU Step En = 0 */
11765 u16Val += (0 << 15); /* Sync Valid En = 0 */
11766 u16Val += (1 << 8); /* Sync Step Count = 1 */
11767 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11768 }
11769
11770 /* set 16 Bit mode */
11771 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0860, 0x0020);
11772
11773 pPCM->u8SettingChangeFlag = FALSE;
11774
11775 return s32Ret;
11776 }
11777
HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)11778 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)
11779 {
11780 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11781 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11782 MS_S32 s32Ret = 0;
11783
11784 if (pPcmInfo->u8ConnectFlag == FALSE)
11785 {
11786 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11787 return -A_EPERM;
11788 }
11789
11790 /* stop engine */
11791 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0000);
11792
11793 /* clear PCM buffer */
11794 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR1_BUF_SIZE);
11795
11796 /* flush MIU */
11797 MsOS_FlushMemory();
11798
11799 /* initial dlocal buffer */
11800 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x2000);
11801 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x0000);
11802
11803 /* reset engine */
11804 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x1000);
11805 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x0000);
11806
11807 /* start engine */
11808 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0002);
11809
11810 /* reset write pointer */
11811 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11812
11813 /* reset remain size */
11814 pPCM->tPcmBufferInfo.u32RemainSize = 0;
11815
11816 return s32Ret;
11817 }
11818
HAL_AUDIO_PCM_R2Dma_Reader1_Open(void * pData)11819 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Open(void *pData)
11820 {
11821 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11822 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11823 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
11824 MS_U32 u32TargetBufferAddrPa = 0;
11825 MS_U32 u32TargetBufferSize = 0;
11826 MS_U32 u32TargetChannel = 0;
11827 MS_U32 u32TargetBitWidth = 0;
11828 MS_U32 u32TargetAlignmentSize = 0;
11829 MS_S32 s32Ret = 0;
11830 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
11831
11832 if (pData == NULL)
11833 {
11834 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11835 return -A_EFAULT;
11836 }
11837
11838 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11839
11840 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11841 {
11842 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);
11843 return -A_EINVAL;
11844 }
11845
11846 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11847 {
11848 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
11849 return -A_EINVAL;
11850 }
11851
11852 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11853 {
11854 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11855 return -A_EINVAL;
11856 }
11857
11858 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11859 {
11860 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11861 return -A_EINVAL;
11862 }
11863
11864 if (pUserPcmInfo->u8CaptureFlag == TRUE)
11865 {
11866 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
11867 return -A_EINVAL;
11868 }
11869
11870 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)
11871 {
11872 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
11873 return -A_EINVAL;
11874 }
11875
11876 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)
11877 {
11878 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
11879 return -A_EINVAL;
11880 }
11881
11882 if (pUserPcmInfo->u8MultiChFlag == TRUE)
11883 {
11884 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11885 u32TargetChannel = 10;
11886 }
11887 else
11888 {
11889 /* stereo = 2 channels */
11890 u32TargetChannel = 2;
11891 }
11892
11893 /* calculate buffer size */
11894 u32TargetBitWidth = 16;
11895 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11896 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11897 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11898 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11899 {
11900 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);
11901 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11902 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11903 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
11904 }
11905
11906 /* fill in settings */
11907 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11908 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
11909 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
11910 pPcmInfo->u8ConnectFlag = TRUE;
11911 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11912 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11913 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
11914 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
11915 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
11916 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
11917 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
11918 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
11919 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
11920 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
11921 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
11922 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
11923
11924 /* init DPGA */
11925 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x03, 0x03);
11926 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11927 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11928 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
11929 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_R_CTRL, 0x12, 0x12);
11930
11931 /* init PCM buffer address */
11932 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR1_BUF_ADDR;
11933 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
11934 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
11935 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11936
11937 /* switch R2_DMA & DPGA control to MCU */
11938 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x8000);
11939 HAL_AUR2_WriteMaskReg(R2_DMARDR1_EN, 0x0001, 0x0001);
11940
11941 /* set PCM buffer address */
11942 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
11943 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
11944
11945 /* apply setting */
11946 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11947
11948 /* restart */
11949 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11950
11951 /* TODO : force channel 1~4 to decoder1 when multi-channel output is configured, it's a hardcode */
11952 if (pPcmInfo->u8MultiChFlag == TRUE)
11953 {
11954 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
11955 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
11956 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
11957 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
11958 }
11959
11960 return s32Ret;
11961 }
11962
HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)11963 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)
11964 {
11965 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11966 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11967 MS_S32 s32Ret = 0;
11968 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11969
11970 if (pPcmInfo->u8ConnectFlag != FALSE)
11971 {
11972 HAL_AUDIO_PCM_R2Dma_Reader1_Flush();
11973 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11974 }
11975
11976 /* Switch R2_DMA & DPGA control to R2 */
11977 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x0000);
11978 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x01, 0x00);
11979
11980 return s32Ret;
11981 }
11982
HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)11983 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)
11984 {
11985 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11986 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11987 MS_S32 s32Ret = 0;
11988 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11989
11990 if (pPcmInfo->u8StartFlag == FALSE)
11991 {
11992 if (pPCM->u8SettingChangeFlag == TRUE)
11993 {
11994 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11995 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11996 }
11997
11998 /* enable engine's MIU access */
11999 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0001);
12000
12001 pPcmInfo->u8StartFlag = TRUE;
12002 }
12003
12004 return s32Ret;
12005 }
12006
HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)12007 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)
12008 {
12009 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12010 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12011 MS_S32 s32Ret = 0;
12012 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
12013
12014 if (pPcmInfo->u8StartFlag != FALSE)
12015 {
12016 /* disable engine's MIU access */
12017 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0000);
12018
12019 pPcmInfo->u8StartFlag = FALSE;
12020 }
12021
12022 return s32Ret;
12023 }
12024
HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd,const void * pData)12025 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
12026 {
12027 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12028 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12029 MS_S32 s32Ret = 0;
12030 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12031
12032 if (pData == NULL)
12033 {
12034 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12035 return -A_EFAULT;
12036 }
12037
12038 if (pPcmInfo->u8ConnectFlag == FALSE)
12039 {
12040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12041 return -A_EPERM;
12042 }
12043
12044 switch(u32Cmd)
12045 {
12046 case AUDIO_PCM_CMD_NONBLOCKING:
12047 {
12048 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
12049
12050 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
12051 {
12052 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
12053 s32Ret = -A_EINVAL;
12054 break;
12055 }
12056
12057 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
12058
12059 break;
12060 }
12061
12062 case AUDIO_PCM_CMD_MULTICH:
12063 {
12064 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
12065
12066 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
12067 {
12068 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
12069 s32Ret = -A_EINVAL;
12070 break;
12071 }
12072
12073 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12074 {
12075 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12076 s32Ret = -A_EINVAL;
12077 break;
12078 }
12079
12080 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
12081
12082 break;
12083 }
12084
12085 case AUDIO_PCM_CMD_MIXING:
12086 {
12087 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
12088
12089 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
12090 {
12091 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
12092 s32Ret = -A_EINVAL;
12093 break;
12094 }
12095
12096 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12097 {
12098 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12099 s32Ret = -A_EINVAL;
12100 break;
12101 }
12102
12103 pPcmInfo->u8MixingFlag = FALSE;
12104
12105 break;
12106 }
12107
12108 case AUDIO_PCM_CMD_MIXINGGROUP:
12109 {
12110 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
12111
12112 pPcmInfo->u32MixingGroup = u32MixingGroup;
12113
12114 break;
12115 }
12116
12117 case AUDIO_PCM_CMD_BUFFERDURATION:
12118 {
12119 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
12120
12121 if (u32BufferDuration == 0)
12122 {
12123 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
12124 s32Ret = -A_EINVAL;
12125 break;
12126 }
12127
12128 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
12129 {
12130 pPcmInfo->u32BufferDuration = u32BufferDuration;
12131 pPCM->u8SettingChangeFlag = TRUE;
12132 }
12133
12134 break;
12135 }
12136
12137 case AUDIO_PCM_CMD_CHANNEL:
12138 {
12139 MS_U32 u32Channel = *((MS_U32 *)pData);
12140
12141 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12142 {
12143 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
12144 return -A_EINVAL;
12145 }
12146
12147 if (pPcmInfo->u32Channel != u32Channel)
12148 {
12149 pPcmInfo->u32Channel = u32Channel;
12150 pPCM->u8SettingChangeFlag = TRUE;
12151 }
12152
12153 break;
12154 }
12155
12156 case AUDIO_PCM_CMD_SAMPLERATE:
12157 {
12158 MS_U32 u32SampleRate = *((MS_U32 *)pData);
12159
12160 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12161 {
12162 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
12163 return -A_EINVAL;
12164 }
12165
12166 if (pPcmInfo->u32SampleRate != u32SampleRate)
12167 {
12168 pPcmInfo->u32SampleRate = u32SampleRate;
12169 pPCM->u8SettingChangeFlag = TRUE;
12170 }
12171
12172 break;
12173 }
12174
12175 case AUDIO_PCM_CMD_BITWIDTH:
12176 {
12177 MS_U32 u32BitWidth = *((MS_U32 *)pData);
12178
12179 pPcmInfo->u32BitWidth = u32BitWidth;
12180
12181 break;
12182 }
12183
12184 case AUDIO_PCM_CMD_BIGENDIAN:
12185 {
12186 MS_U32 u32BigEndian = *((MS_U32 *)pData);
12187
12188 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
12189 {
12190 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
12191 return -A_EINVAL;
12192 }
12193
12194 pPcmInfo->u32BigEndian = u32BigEndian;
12195
12196 break;
12197 }
12198
12199 case AUDIO_PCM_CMD_TIMESTAMP:
12200 {
12201 MS_U32 u32Timestamp = *((MS_U32 *)pData);
12202
12203 pPcmInfo->u32Timestamp = u32Timestamp;
12204
12205 break;
12206 }
12207
12208 case AUDIO_PCM_CMD_WEIGHTING:
12209 {
12210 MS_U32 u32Weighting = *((MS_U32 *)pData);
12211
12212 if (u32Weighting > 100)
12213 {
12214 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
12215 return -A_EINVAL;
12216 }
12217
12218 pPcmInfo->u32Weighting = u32Weighting;
12219
12220 break;
12221 }
12222
12223 case AUDIO_PCM_CMD_VOLUME:
12224 {
12225 MS_U32 u32Volume = *((MS_U32 *)pData);
12226
12227 if (u32Volume > 100)
12228 {
12229 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
12230 return -A_EINVAL;
12231 }
12232
12233 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
12234
12235 break;
12236 }
12237
12238 case AUDIO_PCM_CMD_MUTE:
12239 {
12240 MS_U32 u32Mute = *((MS_U32*)pData);
12241
12242 if (u32Mute == TRUE)
12243 {
12244 pPcmInfo->u32Volume |= 0x80000000;
12245 }
12246 else if (u32Mute == FALSE)
12247 {
12248 pPcmInfo->u32Volume &= 0x7FFFFFFF;
12249 }
12250 else
12251 {
12252 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
12253 s32Ret = -A_EINVAL;
12254 }
12255 break;
12256 }
12257
12258 default:
12259 {
12260 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12261 break;
12262 }
12263 }
12264
12265 return s32Ret;
12266 }
12267
HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd,void * pData)12268 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd, void *pData)
12269 {
12270 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12271 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12272 MS_S32 s32Ret = 0;
12273 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12274
12275 if (pData == NULL)
12276 {
12277 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12278 return -A_EFAULT;
12279 }
12280
12281 if (pPcmInfo->u8ConnectFlag == FALSE)
12282 {
12283 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12284 return -A_EPERM;
12285 }
12286
12287 switch(u32Cmd)
12288 {
12289 case AUDIO_PCM_CMD_ALL:
12290 {
12291 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12292 MS_U32 u32MinSize = 0;
12293
12294 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12295 {
12296 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);
12297 s32Ret = -A_EINVAL;
12298 break;
12299 }
12300 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
12301 {
12302 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);
12303 }
12304
12305 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
12306 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
12307 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
12308
12309 break;
12310 }
12311
12312 case AUDIO_PCM_CMD_NONBLOCKING:
12313 {
12314 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
12315 break;
12316 }
12317
12318 case AUDIO_PCM_CMD_MULTICH:
12319 {
12320 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
12321 break;
12322 }
12323
12324 case AUDIO_PCM_CMD_MIXING:
12325 {
12326 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
12327 break;
12328 }
12329
12330 case AUDIO_PCM_CMD_MIXINGGROUP:
12331 {
12332 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
12333 break;
12334 }
12335
12336 case AUDIO_PCM_CMD_BUFFER:
12337 {
12338 /*
12339 * TODO, need better coding
12340 *
12341 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
12342 */
12343 break;
12344 }
12345
12346 case AUDIO_PCM_CMD_BUFFERDURATION:
12347 {
12348 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
12349 break;
12350 }
12351
12352 case AUDIO_PCM_CMD_READPTR:
12353 {
12354 /*
12355 * TODO, need better coding
12356 *
12357 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
12358 */
12359 break;
12360 }
12361
12362 case AUDIO_PCM_CMD_WRITEPTR:
12363 {
12364 /*
12365 * TODO, need better coding
12366 *
12367 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
12368 */
12369 break;
12370 }
12371
12372 case AUDIO_PCM_CMD_CHANNEL:
12373 {
12374 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
12375 break;
12376 }
12377
12378 case AUDIO_PCM_CMD_SAMPLERATE:
12379 {
12380 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
12381 break;
12382 }
12383
12384 case AUDIO_PCM_CMD_BITWIDTH:
12385 {
12386 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
12387 break;
12388 }
12389
12390 case AUDIO_PCM_CMD_BIGENDIAN:
12391 {
12392 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
12393 break;
12394 }
12395
12396 case AUDIO_PCM_CMD_TIMESTAMP:
12397 {
12398 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
12399 break;
12400 }
12401
12402 case AUDIO_PCM_CMD_WEIGHTING:
12403 {
12404 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
12405 break;
12406 }
12407
12408 case AUDIO_PCM_CMD_VOLUME:
12409 {
12410 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
12411 break;
12412 }
12413
12414 case AUDIO_PCM_CMD_BUFFERLEVEL:
12415 {
12416 MS_U32 u32BufferLevel1 = 0;
12417 MS_U32 u32BufferLevel2 = 0;
12418 MS_U32 u32Timeout = 20;
12419
12420 while (u32Timeout > 0)
12421 {
12422 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12423 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12424
12425 if (u32BufferLevel1 == u32BufferLevel2)
12426 {
12427 break;
12428 }
12429
12430 u32Timeout--;
12431
12432 #ifdef MSOS_TYPE_LINUX_KERNEL
12433 udelay(1);
12434 #else
12435 AUDIO_DELAY1US(1);
12436 #endif
12437 }
12438
12439 if (u32BufferLevel1 != u32BufferLevel2)
12440 {
12441 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
12442 }
12443
12444 pPcmInfo->u32BufferLevel = u32BufferLevel2;
12445 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12446
12447 break;
12448 }
12449
12450 case AUDIO_PCM_CMD_MUTE:
12451 {
12452 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12453 break;
12454 }
12455
12456 case AUDIO_PCM_CMD_BUFFERSIZE:
12457 {
12458 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
12459 break;
12460 }
12461
12462 default:
12463 {
12464 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12465 break;
12466 }
12467 }
12468
12469 return s32Ret;
12470 }
12471
HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void * pBuf,MS_U32 u32Size)12472 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
12473 {
12474 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12475 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12476 MS_S8 *pBufTmp = NULL;
12477 MS_U32 u32BufferSize = 0;
12478 MS_U32 u32PcmLevel = 0;
12479 MS_U32 u32RequestSize = 0;
12480 MS_U32 u32RequestSizeTmp = 0;
12481 MS_U32 u32SizeToCopy = 0;
12482 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
12483
12484 if (pBuf == NULL)
12485 {
12486 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
12487 return 0;
12488 }
12489
12490 if (u32Size == 0)
12491 {
12492 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
12493 return 0;
12494 }
12495
12496 if (pPcmInfo->u8ConnectFlag == FALSE)
12497 {
12498 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12499 return 0;
12500 }
12501
12502 if (pPcmInfo->u8StartFlag == FALSE)
12503 {
12504 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
12505 return 0;
12506 }
12507
12508 /*
12509 * A patch here!
12510 * to ensure channel 1~4 are configured as decoder1
12511 */
12512 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x80) ||
12513 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x80) ||
12514 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x80) ||
12515 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x80))
12516 {
12517 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
12518 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
12519 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
12520 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
12521 }
12522
12523 pBufTmp = (MS_S8 *)pBuf;
12524
12525 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12526 if (u32PcmLevel == 0)
12527 {
12528 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
12529 }
12530
12531 u32RequestSize = u32Size;
12532 u32RequestSizeTmp = u32RequestSize;
12533
12534 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
12535
12536 /* copy data to PCM buffer */
12537 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
12538 {
12539 do {
12540 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
12541 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12542
12543 #ifdef MSOS_TYPE_LINUX_KERNEL
12544 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12545 #else
12546 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12547 #endif
12548
12549 pBufTmp += u32SizeToCopy;
12550 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
12551 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12552 {
12553 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12554 {
12555 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12556 }
12557 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12558 }
12559
12560 u32RequestSizeTmp -= u32SizeToCopy;
12561 } while (u32RequestSizeTmp > 0);
12562
12563 /* flush MIU */
12564 MsOS_FlushMemory();
12565
12566 /* update copied size to engine */
12567 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
12568 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
12569 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0400);
12570 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0000);
12571 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
12572
12573 return u32Size;
12574 }
12575
12576 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
12577
12578 return 0;
12579 }
12580
HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)12581 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)
12582 {
12583 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12584 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12585 MS_S32 s32Ret = 0;
12586 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12587
12588 if (pPcmInfo->u8StartFlag == FALSE)
12589 {
12590 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
12591 HAL_AUDIO_PCM_R2Dma_Reader1_Stop();
12592 }
12593
12594 return s32Ret;
12595 }
12596 #endif
12597
12598 #if AUDIO_R2_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)12599 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)
12600 {
12601 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12602 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12603 MS_U16 u16Val = 0;
12604 MS_U16 u16Synthrate_H = 0;
12605 MS_U16 u16Synthrate_L = 0;
12606 MS_U32 u32TargetBufferSize = 0;
12607 MS_U32 u32TargetChannel = 0;
12608 MS_U32 u32TargetBitWidth = 0;
12609 MS_U32 u32TargetAlignmentSize = 0;
12610 MS_S32 s32Ret = 0;
12611
12612 switch(pPcmInfo->u32SampleRate) {
12613 case 8000:
12614 {
12615 u16Synthrate_H = 0x6978;
12616 u16Synthrate_L = 0x0000;
12617 break;
12618 }
12619
12620 case 11025:
12621 {
12622 u16Synthrate_H = 0x4C87;
12623 u16Synthrate_L = 0xD634;
12624 break;
12625 }
12626
12627 case 12000:
12628 {
12629 u16Synthrate_H = 0x4650;
12630 u16Synthrate_L = 0x0000;
12631 break;
12632 }
12633
12634 case 16000:
12635 {
12636 u16Synthrate_H = 0x34BC;
12637 u16Synthrate_L = 0x0000;
12638 break;
12639 }
12640
12641 case 22050:
12642 {
12643 u16Synthrate_H = 0x2643;
12644 u16Synthrate_L = 0xEB1A;
12645 break;
12646 }
12647
12648 case 24000:
12649 {
12650 u16Synthrate_H = 0x2328;
12651 u16Synthrate_L = 0x0000;
12652 break;
12653 }
12654
12655 case 32000:
12656 {
12657 u16Synthrate_H = 0x1A5E;
12658 u16Synthrate_L = 0x0000;
12659 break;
12660 }
12661
12662 case 44100:
12663 {
12664 u16Synthrate_H = 0x1321;
12665 u16Synthrate_L = 0xF58D;
12666 break;
12667 }
12668
12669 case 48000:
12670 {
12671 u16Synthrate_H = 0x1194;
12672 u16Synthrate_L = 0x0000;
12673 break;
12674 }
12675
12676 case 64000:
12677 {
12678 u16Synthrate_H = 0x0D2F;
12679 u16Synthrate_L = 0x0000;
12680 break;
12681 }
12682
12683 case 88200:
12684 {
12685 u16Synthrate_H = 0x0990;
12686 u16Synthrate_L = 0xFAC6;
12687 break;
12688 }
12689
12690 case 96000:
12691 {
12692 u16Synthrate_H = 0x08CA;
12693 u16Synthrate_L = 0x0000;
12694 break;
12695 }
12696
12697 default:
12698 {
12699 u16Synthrate_H = 0x1194;
12700 u16Synthrate_L = 0x0000;
12701 pPcmInfo->u32SampleRate = 48000;
12702 break;
12703 }
12704 }
12705
12706 /* disable output */
12707 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x7FFF, 0x0000);
12708
12709 /* set synthesizer */
12710 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
12711 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
12712 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12713 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0404); /* SYTH3 bit10 RIU control, bit3 update */
12714 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12715
12716 if (pPcmInfo->u8MultiChFlag == TRUE)
12717 {
12718 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12719 u32TargetChannel = 10;
12720 }
12721 else
12722 {
12723 /* stereo = 2 channels */
12724 u32TargetChannel = 2;
12725 }
12726
12727 /* calculate buffer size */
12728 u32TargetBitWidth = 16;
12729 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12730 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12731 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12732 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12733 {
12734 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);
12735 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12736 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12737 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
12738 }
12739
12740 /* set buffer size */
12741 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
12742
12743 /* set overrun & underrun threshold */
12744 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize>> 3)) / BYTES_IN_MIU_LINE));
12745 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
12746
12747 /* set channel mode */
12748 if (pPcmInfo->u8MultiChFlag == TRUE)
12749 {
12750 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12751 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x00);
12752 u16Val = 19; /* MIU burst length = 19 */
12753 u16Val += (1 << 7); /* MIU Step En = 1 */
12754 u16Val += (1 << 15); /* Sync Valid En = 1 */
12755 u16Val += (1 << 8); /* Sync Step Count = 1 */
12756 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12757 }
12758 else
12759 {
12760 /* Stereo mode : stereo = 2 channels */
12761 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x80);
12762 u16Val = 3; /* MIU burst length = 3 */
12763 u16Val += (0 << 7); /* MIU Step En = 0 */
12764 u16Val += (0 << 15); /* Sync Valid En = 0 */
12765 u16Val += (1 << 8); /* Sync Step Count = 1 */
12766 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12767 }
12768
12769 /* set 16 Bit mode */
12770 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0860, 0x0020);
12771
12772 pPCM->u8SettingChangeFlag = FALSE;
12773
12774 return s32Ret;
12775 }
12776
HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)12777 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)
12778 {
12779 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12780 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12781 MS_S32 s32Ret = 0;
12782
12783 if (pPcmInfo->u8ConnectFlag == FALSE)
12784 {
12785 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12786 return -A_EPERM;
12787 }
12788
12789 /* stop engine */
12790 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0000);
12791
12792 /* clear PCM buffer */
12793 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR2_BUF_SIZE);
12794
12795 /* flush MIU */
12796 MsOS_FlushMemory();
12797
12798 /* initial dlocal buffer */
12799 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x2000);
12800 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x0000);
12801
12802 /* reset engine */
12803 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x1000);
12804 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x0000);
12805
12806 /* start engine */
12807 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0002);
12808
12809 /* reset write pointer */
12810 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12811
12812 /* reset remain size */
12813 pPCM->tPcmBufferInfo.u32RemainSize = 0;
12814
12815 return s32Ret;
12816 }
12817
HAL_AUDIO_PCM_R2Dma_Reader2_Open(void * pData)12818 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Open(void *pData)
12819 {
12820 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12821 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12822 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
12823 MS_U32 u32TargetBufferAddrPa = 0;
12824 MS_U32 u32TargetBufferSize = 0;
12825 MS_U32 u32TargetChannel = 0;
12826 MS_U32 u32TargetBitWidth = 0;
12827 MS_U32 u32TargetAlignmentSize = 0;
12828 MS_S32 s32Ret = 0;
12829 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
12830
12831 if (pData == NULL)
12832 {
12833 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12834 return -A_EFAULT;
12835 }
12836
12837 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12838
12839 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12840 {
12841 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);
12842 return -A_EINVAL;
12843 }
12844
12845 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12846 {
12847 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
12848 return -A_EINVAL;
12849 }
12850
12851 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12852 {
12853 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12854 return -A_EINVAL;
12855 }
12856
12857 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12858 {
12859 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12860 return -A_EINVAL;
12861 }
12862
12863 if (pUserPcmInfo->u8CaptureFlag == TRUE)
12864 {
12865 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
12866 return -A_EINVAL;
12867 }
12868
12869 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)
12870 {
12871 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
12872 return -A_EINVAL;
12873 }
12874
12875 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)
12876 {
12877 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
12878 return -A_EINVAL;
12879 }
12880
12881 if (pUserPcmInfo->u8MultiChFlag == TRUE)
12882 {
12883 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12884 u32TargetChannel = 10;
12885 }
12886 else
12887 {
12888 /* stereo = 2 channels */
12889 u32TargetChannel = 2;
12890 }
12891
12892 /* calculate buffer size */
12893 u32TargetBitWidth = 16;
12894 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12895 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12896 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12897 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12898 {
12899 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);
12900 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12901 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12902 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
12903 }
12904
12905 /* fill in settings */
12906 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12907 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
12908 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
12909 pPcmInfo->u8ConnectFlag = TRUE;
12910 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12911 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12912 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
12913 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
12914 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
12915 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
12916 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
12917 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
12918 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
12919 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
12920 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
12921 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
12922
12923 /* init DPGA */
12924 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x03, 0x03);
12925 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12926 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12927 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
12928 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_R_CTRL, 0x12, 0x12);
12929
12930 /* init PCM buffer address */
12931 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR2_BUF_ADDR;
12932 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
12933 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
12934 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12935
12936 /* switch R2_DMA & DPGA control to MCU */
12937 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x8000);
12938 HAL_AUR2_WriteMaskReg(R2_DMARDR2_EN, 0x0001, 0x0001);
12939
12940 /* set PCM buffer address */
12941 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
12942 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
12943
12944 /* apply setting */
12945 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12946
12947 /* restart */
12948 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12949
12950 /* TODO : force channel 1~4 to decoder3 when multi-channel output is configured, it's a hardcode */
12951 if (pPcmInfo->u8MultiChFlag == TRUE)
12952 {
12953 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
12954 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
12955 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
12956 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
12957 }
12958
12959 return s32Ret;
12960 }
12961
HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)12962 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)
12963 {
12964 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12965 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12966 MS_S32 s32Ret = 0;
12967 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
12968
12969 if (pPcmInfo->u8ConnectFlag != FALSE)
12970 {
12971 HAL_AUDIO_PCM_R2Dma_Reader2_Flush();
12972 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12973 }
12974
12975 /* switch R2_DMA & DPGA control to R2 */
12976 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x0000);
12977 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x01, 0x00);
12978
12979 return s32Ret;
12980 }
12981
HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)12982 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)
12983 {
12984 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12985 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12986 MS_S32 s32Ret = 0;
12987 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
12988
12989 if (pPcmInfo->u8StartFlag == FALSE)
12990 {
12991 if (pPCM->u8SettingChangeFlag == TRUE)
12992 {
12993 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12994 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12995 }
12996
12997 /* enable engine's MIU access */
12998 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0001);
12999
13000 pPcmInfo->u8StartFlag = TRUE;
13001 }
13002
13003 return s32Ret;
13004 }
13005
HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)13006 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)
13007 {
13008 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13009 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13010 MS_S32 s32Ret = 0;
13011 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13012
13013 if (pPcmInfo->u8StartFlag != FALSE)
13014 {
13015 /* disable engine's MIU access */
13016 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0000);
13017
13018 pPcmInfo->u8StartFlag = FALSE;
13019 }
13020
13021 return s32Ret;
13022 }
13023
HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd,const void * pData)13024 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
13025 {
13026 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13027 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13028 MS_S32 s32Ret = 0;
13029 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13030
13031 if (pData == NULL)
13032 {
13033 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13034 return -A_EFAULT;
13035 }
13036
13037 if (pPcmInfo->u8ConnectFlag == FALSE)
13038 {
13039 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13040 return -A_EPERM;
13041 }
13042
13043 switch(u32Cmd)
13044 {
13045 case AUDIO_PCM_CMD_NONBLOCKING:
13046 {
13047 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13048
13049 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13050 {
13051 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13052 s32Ret = -A_EINVAL;
13053 break;
13054 }
13055
13056 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13057
13058 break;
13059 }
13060
13061 case AUDIO_PCM_CMD_MULTICH:
13062 {
13063 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13064
13065 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13066 {
13067 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13068 s32Ret = -A_EINVAL;
13069 break;
13070 }
13071
13072 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13073 {
13074 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13075 s32Ret = -A_EINVAL;
13076 break;
13077 }
13078
13079 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
13080
13081 break;
13082 }
13083
13084 case AUDIO_PCM_CMD_MIXING:
13085 {
13086 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13087
13088 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13089 {
13090 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13091 s32Ret = -A_EINVAL;
13092 break;
13093 }
13094
13095 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13096 {
13097 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13098 s32Ret = -A_EINVAL;
13099 break;
13100 }
13101
13102 pPcmInfo->u8MixingFlag = FALSE;
13103
13104 break;
13105 }
13106
13107 case AUDIO_PCM_CMD_MIXINGGROUP:
13108 {
13109 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13110
13111 pPcmInfo->u32MixingGroup = u32MixingGroup;
13112
13113 break;
13114 }
13115
13116 case AUDIO_PCM_CMD_BUFFERDURATION:
13117 {
13118 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
13119
13120 if (u32BufferDuration == 0)
13121 {
13122 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
13123 s32Ret = -A_EINVAL;
13124 break;
13125 }
13126
13127 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
13128 {
13129 pPcmInfo->u32BufferDuration = u32BufferDuration;
13130 pPCM->u8SettingChangeFlag = TRUE;
13131 }
13132
13133 break;
13134 }
13135
13136 case AUDIO_PCM_CMD_CHANNEL:
13137 {
13138 MS_U32 u32Channel = *((MS_U32 *)pData);
13139
13140 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
13141 {
13142 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
13143 return -A_EINVAL;
13144 }
13145
13146 if (pPcmInfo->u32Channel != u32Channel)
13147 {
13148 pPcmInfo->u32Channel = u32Channel;
13149 pPCM->u8SettingChangeFlag = TRUE;
13150 }
13151
13152 break;
13153 }
13154
13155 case AUDIO_PCM_CMD_SAMPLERATE:
13156 {
13157 MS_U32 u32SampleRate = *((MS_U32 *)pData);
13158
13159 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
13160 {
13161 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
13162 return -A_EINVAL;
13163 }
13164
13165 if (pPcmInfo->u32SampleRate != u32SampleRate)
13166 {
13167 pPcmInfo->u32SampleRate = u32SampleRate;
13168 pPCM->u8SettingChangeFlag = TRUE;
13169 }
13170
13171 break;
13172 }
13173
13174 case AUDIO_PCM_CMD_BITWIDTH:
13175 {
13176 MS_U32 u32BitWidth = *((MS_U32 *)pData);
13177
13178 pPcmInfo->u32BitWidth = u32BitWidth;
13179
13180 break;
13181 }
13182
13183 case AUDIO_PCM_CMD_BIGENDIAN:
13184 {
13185 MS_U32 u32BigEndian = *((MS_U32 *)pData);
13186
13187 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
13188 {
13189 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
13190 return -A_EINVAL;
13191 }
13192
13193 pPcmInfo->u32BigEndian = u32BigEndian;
13194
13195 break;
13196 }
13197
13198 case AUDIO_PCM_CMD_TIMESTAMP:
13199 {
13200 MS_U32 u32Timestamp = *((MS_U32 *)pData);
13201
13202 pPcmInfo->u32Timestamp = u32Timestamp;
13203
13204 break;
13205 }
13206
13207 case AUDIO_PCM_CMD_WEIGHTING:
13208 {
13209 MS_U32 u32Weighting = *((MS_U32 *)pData);
13210
13211 if (u32Weighting > 100)
13212 {
13213 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
13214 return -A_EINVAL;
13215 }
13216
13217 pPcmInfo->u32Weighting = u32Weighting;
13218
13219 break;
13220 }
13221
13222 case AUDIO_PCM_CMD_VOLUME:
13223 {
13224 MS_U32 u32Volume = *((MS_U32 *)pData);
13225
13226 if (u32Volume > 100)
13227 {
13228 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
13229 return -A_EINVAL;
13230 }
13231
13232 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
13233
13234 break;
13235 }
13236
13237 case AUDIO_PCM_CMD_MUTE:
13238 {
13239 MS_U32 u32Mute = *((MS_U32*)pData);
13240
13241 if (u32Mute == TRUE)
13242 {
13243 pPcmInfo->u32Volume |= 0x80000000;
13244 }
13245 else if (u32Mute == FALSE)
13246 {
13247 pPcmInfo->u32Volume &= 0x7FFFFFFF;
13248 }
13249 else
13250 {
13251 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
13252 s32Ret = -A_EINVAL;
13253 }
13254 break;
13255 }
13256
13257 default:
13258 {
13259 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13260 break;
13261 }
13262 }
13263
13264 return s32Ret;
13265 }
13266
HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd,void * pData)13267 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd, void *pData)
13268 {
13269 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13270 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13271 MS_S32 s32Ret = 0;
13272 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13273
13274 if (pData == NULL)
13275 {
13276 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13277 return -A_EFAULT;
13278 }
13279
13280 if (pPcmInfo->u8ConnectFlag == FALSE)
13281 {
13282 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13283 return -A_EPERM;
13284 }
13285
13286 switch(u32Cmd)
13287 {
13288 case AUDIO_PCM_CMD_ALL:
13289 {
13290 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13291 MS_U32 u32MinSize = 0;
13292
13293 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13294 {
13295 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);
13296 s32Ret = -A_EINVAL;
13297 break;
13298 }
13299 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
13300 {
13301 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);
13302 }
13303
13304 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
13305 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
13306 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
13307
13308 break;
13309 }
13310
13311 case AUDIO_PCM_CMD_NONBLOCKING:
13312 {
13313 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
13314 break;
13315 }
13316
13317 case AUDIO_PCM_CMD_MULTICH:
13318 {
13319 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
13320 break;
13321 }
13322
13323 case AUDIO_PCM_CMD_MIXING:
13324 {
13325 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
13326 break;
13327 }
13328
13329 case AUDIO_PCM_CMD_MIXINGGROUP:
13330 {
13331 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
13332 break;
13333 }
13334
13335 case AUDIO_PCM_CMD_BUFFER:
13336 {
13337 /*
13338 * TODO, need better coding
13339 *
13340 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
13341 */
13342 break;
13343 }
13344
13345 case AUDIO_PCM_CMD_BUFFERDURATION:
13346 {
13347 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
13348 break;
13349 }
13350
13351 case AUDIO_PCM_CMD_READPTR:
13352 {
13353 /*
13354 * TODO, need better coding
13355 *
13356 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
13357 */
13358 break;
13359 }
13360
13361 case AUDIO_PCM_CMD_WRITEPTR:
13362 {
13363 /*
13364 * TODO, need better coding
13365 *
13366 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
13367 */
13368 break;
13369 }
13370
13371 case AUDIO_PCM_CMD_CHANNEL:
13372 {
13373 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
13374 break;
13375 }
13376
13377 case AUDIO_PCM_CMD_SAMPLERATE:
13378 {
13379 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
13380 break;
13381 }
13382
13383 case AUDIO_PCM_CMD_BITWIDTH:
13384 {
13385 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
13386 break;
13387 }
13388
13389 case AUDIO_PCM_CMD_BIGENDIAN:
13390 {
13391 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
13392 break;
13393 }
13394
13395 case AUDIO_PCM_CMD_TIMESTAMP:
13396 {
13397 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
13398 break;
13399 }
13400
13401 case AUDIO_PCM_CMD_WEIGHTING:
13402 {
13403 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
13404 break;
13405 }
13406
13407 case AUDIO_PCM_CMD_VOLUME:
13408 {
13409 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
13410 break;
13411 }
13412
13413 case AUDIO_PCM_CMD_BUFFERLEVEL:
13414 {
13415 MS_U32 u32BufferLevel1 = 0;
13416 MS_U32 u32BufferLevel2 = 0;
13417 MS_U32 u32Timeout = 20;
13418
13419 while (u32Timeout > 0)
13420 {
13421 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
13422 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
13423
13424 if (u32BufferLevel1 == u32BufferLevel2)
13425 {
13426 break;
13427 }
13428
13429 u32Timeout--;
13430
13431 #ifdef MSOS_TYPE_LINUX_KERNEL
13432 udelay(1);
13433 #else
13434 AUDIO_DELAY1US(1);
13435 #endif
13436 }
13437
13438 if (u32BufferLevel1 != u32BufferLevel2)
13439 {
13440 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
13441 }
13442
13443 pPcmInfo->u32BufferLevel = u32BufferLevel2;
13444 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
13445
13446 break;
13447 }
13448
13449 case AUDIO_PCM_CMD_MUTE:
13450 {
13451 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
13452 break;
13453 }
13454
13455 case AUDIO_PCM_CMD_BUFFERSIZE:
13456 {
13457 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
13458 break;
13459 }
13460
13461 default:
13462 {
13463 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13464 break;
13465 }
13466 }
13467
13468 return s32Ret;
13469 }
13470
HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void * pBuf,MS_U32 u32Size)13471 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
13472 {
13473 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13474 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13475 MS_S8 *pBufTmp = NULL;
13476 MS_U32 u32BufferSize = 0;
13477 MS_U32 u32PcmLevel = 0;
13478 MS_U32 u32RequestSize = 0;
13479 MS_U32 u32RequestSizeTmp = 0;
13480 MS_U32 u32SizeToCopy = 0;
13481 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
13482
13483 if (pBuf == NULL)
13484 {
13485 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
13486 return 0;
13487 }
13488
13489 if (u32Size == 0)
13490 {
13491 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
13492 return 0;
13493 }
13494
13495 if (pPcmInfo->u8ConnectFlag == FALSE)
13496 {
13497 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13498 return 0;
13499 }
13500
13501 if (pPcmInfo->u8StartFlag == FALSE)
13502 {
13503 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
13504 return 0;
13505 }
13506
13507 /*
13508 * A patch here!
13509 * to ensure channel 1~4 are configured as decoder3
13510 */
13511 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x82) ||
13512 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x82) ||
13513 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x82) ||
13514 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x82))
13515 {
13516 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
13517 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
13518 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
13519 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
13520 }
13521
13522 pBufTmp = (MS_S8 *)pBuf;
13523
13524 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
13525 if (u32PcmLevel == 0)
13526 {
13527 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
13528 }
13529
13530 u32RequestSize = u32Size;
13531 u32RequestSizeTmp = u32RequestSize;
13532
13533 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
13534
13535 /* copy data to PCM buffer */
13536 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
13537 {
13538 do {
13539 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
13540 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
13541
13542 #ifdef MSOS_TYPE_LINUX_KERNEL
13543 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
13544 #else
13545 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
13546 #endif
13547
13548 pBufTmp += u32SizeToCopy;
13549 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
13550 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13551 {
13552 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13553 {
13554 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
13555 }
13556 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13557 }
13558
13559 u32RequestSizeTmp -= u32SizeToCopy;
13560 } while (u32RequestSizeTmp > 0);
13561
13562 /* flush MIU */
13563 MsOS_FlushMemory();
13564
13565 /* update copied size to engine */
13566 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
13567 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
13568 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0400);
13569 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0000);
13570 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
13571
13572 return u32Size;
13573 }
13574
13575 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
13576
13577 return 0;
13578 }
13579
HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)13580 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)
13581 {
13582 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13583 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13584 MS_S32 s32Ret = 0;
13585 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13586
13587 if (pPcmInfo->u8StartFlag == FALSE)
13588 {
13589 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
13590 HAL_AUDIO_PCM_R2Dma_Reader2_Stop();
13591 }
13592
13593 return s32Ret;
13594 }
13595 #endif
13596
13597 #if AUDIO_PCM_CAPTURE1_SUPPORT
HAL_AUDIO_PCM_Capture1_Restart(void)13598 MS_S32 HAL_AUDIO_PCM_Capture1_Restart(void)
13599 {
13600 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13601 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13602 MS_U32 u32WritePtrOffset = 0;
13603 MS_U32 u32TimeoutCounter = 0;
13604 MS_S32 s32Ret = 0;
13605
13606 if (pPcmInfo->u8ConnectFlag == FALSE)
13607 {
13608 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13609 return -A_EPERM;
13610 }
13611
13612 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0x0000);
13613
13614 do {
13615 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13616
13617 if (u32WritePtrOffset != 0)
13618 {
13619 #ifdef MSOS_TYPE_LINUX_KERNEL
13620 udelay(50);
13621 #else
13622 AUDIO_DELAY1US(50);
13623 #endif
13624 u32TimeoutCounter++;
13625 }
13626 else
13627 {
13628 break;
13629 }
13630 } while (u32TimeoutCounter < 10000);
13631
13632 /* clear PCM buffer */
13633 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE1_BUF_SIZE);
13634
13635 /* flush MIU */
13636 MsOS_FlushMemory();
13637
13638 /* reset PCM capture1 read & write pointer */
13639 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13640 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13641 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0x0000);
13642
13643 return s32Ret;
13644 }
13645
HAL_AUDIO_PCM_Capture1_Open(void * pData)13646 MS_S32 HAL_AUDIO_PCM_Capture1_Open(void *pData)
13647 {
13648 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13649 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13650 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13651 MS_U32 u32TargetBufferAddrPa = 0;
13652 MS_S32 s32Ret = 0;
13653 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13654
13655 if (pData == NULL)
13656 {
13657 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13658 return -A_EFAULT;
13659 }
13660
13661 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13662
13663 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13664 {
13665 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);
13666 return -A_EINVAL;
13667 }
13668
13669 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13670 {
13671 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
13672 return -A_EINVAL;
13673 }
13674
13675 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13676 {
13677 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13678 return -A_EINVAL;
13679 }
13680
13681 if (pUserPcmInfo->u8MixingFlag == TRUE)
13682 {
13683 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13684 return -A_EINVAL;
13685 }
13686
13687 if (pUserPcmInfo->u8CaptureFlag != TRUE)
13688 {
13689 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
13690 return -A_EINVAL;
13691 }
13692
13693 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)
13694 {
13695 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13696 return -A_EINVAL;
13697 }
13698
13699 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)
13700 {
13701 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13702 return -A_EINVAL;
13703 }
13704
13705 /* fill in settings */
13706 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13707 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13708 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13709 pPcmInfo->u8ConnectFlag = TRUE;
13710 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13711 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13712 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13713 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13714 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13715 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
13716 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
13717 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
13718 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13719 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13720 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13721 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13722
13723 /* init PCM buffer address */
13724 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
13725 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13726 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13727 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13728
13729 /* restart */
13730 HAL_AUDIO_PCM_Capture1_Restart();
13731
13732 return s32Ret;
13733 }
13734
HAL_AUDIO_PCM_Capture1_Close(void)13735 MS_S32 HAL_AUDIO_PCM_Capture1_Close(void)
13736 {
13737 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13738 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13739 MS_S32 s32Ret = 0;
13740 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13741
13742 if (pPcmInfo->u8ConnectFlag != FALSE)
13743 {
13744 HAL_AUDIO_PCM_Capture1_Flush();
13745 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13746 }
13747
13748 return s32Ret;
13749 }
13750
HAL_AUDIO_PCM_Capture1_Start(void)13751 MS_S32 HAL_AUDIO_PCM_Capture1_Start(void)
13752 {
13753 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13754 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13755 MS_U32 u32BufferSize = 0;
13756 MS_S32 s32Ret = 0;
13757 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13758
13759 if (pPcmInfo->u8StartFlag == FALSE)
13760 {
13761 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13762 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
13763
13764 pPcmInfo->u8StartFlag = TRUE;
13765 }
13766
13767 return s32Ret;
13768 }
13769
HAL_AUDIO_PCM_Capture1_Stop(void)13770 MS_S32 HAL_AUDIO_PCM_Capture1_Stop(void)
13771 {
13772 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13773 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13774 MS_S32 s32Ret = 0;
13775 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13776
13777 if (pPcmInfo->u8StartFlag != FALSE)
13778 {
13779 /* TODO, there is no such control in DSP */
13780
13781 pPcmInfo->u8StartFlag = FALSE;
13782 }
13783
13784 return s32Ret;
13785 }
13786
HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd,const void * pData)13787 MS_S32 HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd, const void *pData)
13788 {
13789 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13790 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13791 MS_S32 s32Ret = 0;
13792 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13793
13794 if (pData == NULL)
13795 {
13796 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13797 return -A_EFAULT;
13798 }
13799
13800 if (pPcmInfo->u8ConnectFlag == FALSE)
13801 {
13802 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13803 return -A_EPERM;
13804 }
13805
13806 switch(u32Cmd)
13807 {
13808 case AUDIO_PCM_CMD_NONBLOCKING:
13809 {
13810 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13811
13812 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13813 {
13814 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13815 s32Ret = -A_EINVAL;
13816 break;
13817 }
13818
13819 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13820
13821 break;
13822 }
13823
13824 case AUDIO_PCM_CMD_MULTICH:
13825 {
13826 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13827
13828 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13829 {
13830 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13831 s32Ret = -A_EINVAL;
13832 break;
13833 }
13834
13835 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13836 {
13837 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13838 s32Ret = -A_EINVAL;
13839 break;
13840 }
13841
13842 pPcmInfo->u8MultiChFlag = FALSE;
13843
13844 break;
13845 }
13846
13847 case AUDIO_PCM_CMD_MIXING:
13848 {
13849 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13850
13851 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13852 {
13853 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13854 s32Ret = -A_EINVAL;
13855 break;
13856 }
13857
13858 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13859 {
13860 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13861 s32Ret = -A_EINVAL;
13862 break;
13863 }
13864
13865 pPcmInfo->u8MixingFlag = FALSE;
13866
13867 break;
13868 }
13869
13870 case AUDIO_PCM_CMD_MIXINGGROUP:
13871 {
13872 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13873
13874 pPcmInfo->u32MixingGroup = u32MixingGroup;
13875
13876 break;
13877 }
13878
13879 case AUDIO_PCM_CMD_BUFFERDURATION:
13880 {
13881 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
13882 s32Ret = -A_EPERM;
13883
13884 break;
13885 }
13886
13887 case AUDIO_PCM_CMD_CHANNEL:
13888 {
13889 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
13890 s32Ret = -A_EPERM;
13891
13892 break;
13893 }
13894
13895 case AUDIO_PCM_CMD_SAMPLERATE:
13896 {
13897 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
13898 s32Ret = -A_EPERM;
13899
13900 break;
13901 }
13902
13903 case AUDIO_PCM_CMD_BITWIDTH:
13904 {
13905 MS_U32 u32BitWidth = *((MS_U32 *)pData);
13906
13907 pPcmInfo->u32BitWidth = u32BitWidth;
13908
13909 break;
13910 }
13911
13912 case AUDIO_PCM_CMD_BIGENDIAN:
13913 {
13914 MS_U32 u32BigEndian = *((MS_U32 *)pData);
13915
13916 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
13917 {
13918 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
13919 return -A_EINVAL;
13920 }
13921
13922 pPcmInfo->u32BigEndian = u32BigEndian;
13923
13924 break;
13925 }
13926
13927 case AUDIO_PCM_CMD_TIMESTAMP:
13928 {
13929 MS_U32 u32Timestamp = *((MS_U32 *)pData);
13930
13931 pPcmInfo->u32Timestamp = u32Timestamp;
13932
13933 break;
13934 }
13935
13936 case AUDIO_PCM_CMD_WEIGHTING:
13937 {
13938 MS_U32 u32Weighting = *((MS_U32 *)pData);
13939
13940 if (u32Weighting > 100)
13941 {
13942 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
13943 return -A_EINVAL;
13944 }
13945
13946 pPcmInfo->u32Weighting = u32Weighting;
13947
13948 break;
13949 }
13950
13951 case AUDIO_PCM_CMD_VOLUME:
13952 {
13953 MS_U32 u32Volume = *((MS_U32 *)pData);
13954
13955 if (u32Volume > 100)
13956 {
13957 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
13958 return -A_EINVAL;
13959 }
13960
13961 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
13962
13963 break;
13964 }
13965
13966 case AUDIO_PCM_CMD_MUTE:
13967 {
13968 MS_U32 u32Mute = *((MS_U32*)pData);
13969
13970 if (u32Mute == TRUE)
13971 {
13972 pPcmInfo->u32Volume |= 0x80000000;
13973 }
13974 else if (u32Mute == FALSE)
13975 {
13976 pPcmInfo->u32Volume &= 0x7FFFFFFF;
13977 }
13978 else
13979 {
13980 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
13981 s32Ret = -A_EINVAL;
13982 }
13983 break;
13984 }
13985
13986 default:
13987 {
13988 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13989 break;
13990 }
13991 }
13992
13993 return s32Ret;
13994 }
13995
HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd,void * pData)13996 MS_S32 HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd, void *pData)
13997 {
13998 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13999 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14000 MS_S32 s32Ret = 0;
14001 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14002
14003 if (pData == NULL)
14004 {
14005 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14006 return -A_EFAULT;
14007 }
14008
14009 if (pPcmInfo->u8ConnectFlag == FALSE)
14010 {
14011 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14012 return -A_EPERM;
14013 }
14014
14015 switch(u32Cmd)
14016 {
14017 case AUDIO_PCM_CMD_ALL:
14018 {
14019 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14020 MS_U32 u32MinSize = 0;
14021
14022 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14023 {
14024 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);
14025 s32Ret = -A_EINVAL;
14026 break;
14027 }
14028 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14029 {
14030 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);
14031 }
14032
14033 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14034 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14035 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14036
14037 break;
14038 }
14039
14040 case AUDIO_PCM_CMD_NONBLOCKING:
14041 {
14042 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14043 break;
14044 }
14045
14046 case AUDIO_PCM_CMD_MULTICH:
14047 {
14048 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14049 break;
14050 }
14051
14052 case AUDIO_PCM_CMD_MIXING:
14053 {
14054 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14055 break;
14056 }
14057
14058 case AUDIO_PCM_CMD_MIXINGGROUP:
14059 {
14060 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14061 break;
14062 }
14063
14064 case AUDIO_PCM_CMD_BUFFER:
14065 {
14066 /*
14067 * TODO, need better coding
14068 *
14069 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14070 */
14071 break;
14072 }
14073
14074 case AUDIO_PCM_CMD_BUFFERDURATION:
14075 {
14076 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14077 break;
14078 }
14079
14080 case AUDIO_PCM_CMD_READPTR:
14081 {
14082 /*
14083 * TODO, need better coding
14084 *
14085 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14086 */
14087 break;
14088 }
14089
14090 case AUDIO_PCM_CMD_WRITEPTR:
14091 {
14092 /*
14093 * TODO, need better coding
14094 *
14095 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14096 */
14097 break;
14098 }
14099
14100 case AUDIO_PCM_CMD_CHANNEL:
14101 {
14102 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14103 break;
14104 }
14105
14106 case AUDIO_PCM_CMD_SAMPLERATE:
14107 {
14108 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14109 break;
14110 }
14111
14112 case AUDIO_PCM_CMD_BITWIDTH:
14113 {
14114 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14115 break;
14116 }
14117
14118 case AUDIO_PCM_CMD_BIGENDIAN:
14119 {
14120 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14121 break;
14122 }
14123
14124 case AUDIO_PCM_CMD_TIMESTAMP:
14125 {
14126 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14127 break;
14128 }
14129
14130 case AUDIO_PCM_CMD_WEIGHTING:
14131 {
14132 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14133 break;
14134 }
14135
14136 case AUDIO_PCM_CMD_VOLUME:
14137 {
14138 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14139 break;
14140 }
14141
14142 case AUDIO_PCM_CMD_BUFFERLEVEL:
14143 {
14144 MS_U32 u32WritePtrOffset = 0;
14145 MS_U32 u32BufferSize = 0;
14146 MS_S32 s32PcmLevel = 0;
14147
14148 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14149 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
14150
14151 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
14152 if (s32PcmLevel < 0)
14153 {
14154 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14155 s32PcmLevel += u32BufferSize;
14156 }
14157
14158 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
14159 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
14160
14161 break;
14162 }
14163
14164 case AUDIO_PCM_CMD_MUTE:
14165 {
14166 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
14167 break;
14168 }
14169
14170 case AUDIO_PCM_CMD_BUFFERSIZE:
14171 {
14172 *((MS_U32 *)pData) = PCM_CAPTURE1_BUF_SIZE;
14173
14174 break;
14175 }
14176
14177 default:
14178 {
14179 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14180 break;
14181 }
14182 }
14183
14184 return s32Ret;
14185 }
14186
HAL_AUDIO_PCM_Capture1_Read(void * pBuf,MS_U32 u32Size)14187 MS_U32 HAL_AUDIO_PCM_Capture1_Read(void *pBuf, MS_U32 u32Size)
14188 {
14189 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14190 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14191 MS_S8 *pBufTmp = NULL;
14192 MS_U32 u32BufferSize = 0;
14193 MS_U32 u32PcmLevel = 0;
14194 MS_U32 u32RequestSize = 0;
14195 MS_U32 u32RequestSizeTmp = 0;
14196 MS_U32 u32SizeToCopy = 0;
14197 MS_U32 u32RptrOffset = 0;
14198 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14199
14200 if (pBuf == NULL)
14201 {
14202 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14203 return 0;
14204 }
14205
14206 if (u32Size == 0)
14207 {
14208 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14209 return 0;
14210 }
14211
14212 if (pPcmInfo->u8ConnectFlag == FALSE)
14213 {
14214 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14215 return 0;
14216 }
14217
14218 if (pPcmInfo->u8StartFlag == FALSE)
14219 {
14220 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
14221 return 0;
14222 }
14223
14224 pBufTmp = (MS_S8 *)pBuf;
14225
14226 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14227 HAL_AUDIO_PCM_Capture1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14228 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE1_BUF_UNIT))
14229 {
14230 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
14231
14232 u32PcmLevel = 0;
14233 HAL_AUDIO_PCM_Capture1_Stop();
14234 HAL_AUDIO_PCM_Capture1_Restart();
14235 HAL_AUDIO_PCM_Capture1_Start();
14236 }
14237
14238 u32RequestSize = u32Size;
14239 u32RequestSizeTmp = u32RequestSize;
14240
14241 /* copy data from PCM buffer */
14242 if (u32PcmLevel >= u32RequestSize)
14243 {
14244 do {
14245 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
14246 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14247
14248 #ifdef MSOS_TYPE_LINUX_KERNEL
14249 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14250 #else
14251 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14252 #endif
14253
14254 pBufTmp += u32SizeToCopy;
14255 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
14256 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14257 {
14258 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14259 {
14260 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14261 }
14262 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14263 }
14264
14265 u32RequestSizeTmp -= u32SizeToCopy;
14266 } while (u32RequestSizeTmp > 0);
14267
14268 /* flush MIU */
14269 MsOS_FlushMemory();
14270
14271 /* update read pointer to engine */
14272 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
14273 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
14274
14275 return u32Size;
14276 }
14277
14278 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14279
14280 return 0;
14281 }
14282
HAL_AUDIO_PCM_Capture1_Flush(void)14283 MS_S32 HAL_AUDIO_PCM_Capture1_Flush(void)
14284 {
14285 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14286 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14287 MS_S32 s32Ret = 0;
14288 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14289
14290 if (pPcmInfo->u8StartFlag == FALSE)
14291 {
14292 HAL_AUDIO_PCM_Capture1_Restart();
14293 HAL_AUDIO_PCM_Capture1_Stop();
14294 }
14295
14296 return s32Ret;
14297 }
14298 #endif
14299
14300 #if AUDIO_PCM_CAPTURE2_SUPPORT
HAL_AUDIO_PCM_Capture2_Restart(void)14301 MS_S32 HAL_AUDIO_PCM_Capture2_Restart(void)
14302 {
14303 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14304 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14305 MS_U32 u32WritePtrOffset = 0;
14306 MS_U32 u32TimeoutCounter = 0;
14307 MS_S32 s32Ret = 0;
14308
14309 if (pPcmInfo->u8ConnectFlag == FALSE)
14310 {
14311 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14312 return -A_EPERM;
14313 }
14314
14315 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0x0000);
14316
14317 do {
14318 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14319
14320 if (u32WritePtrOffset != 0)
14321 {
14322 #ifdef MSOS_TYPE_LINUX_KERNEL
14323 udelay(50);
14324 #else
14325 AUDIO_DELAY1US(50);
14326 #endif
14327 u32TimeoutCounter++;
14328 }
14329 else
14330 {
14331 break;
14332 }
14333 } while (u32TimeoutCounter < 10000);
14334
14335 /* clear PCM buffer */
14336 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE2_BUF_SIZE);
14337
14338 /* flush MIU */
14339 MsOS_FlushMemory();
14340
14341 /* reset PCM capture1 read & write pointer */
14342 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14343 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14344 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0x0000);
14345
14346 return s32Ret;
14347 }
14348
HAL_AUDIO_PCM_Capture2_Open(void * pData)14349 MS_S32 HAL_AUDIO_PCM_Capture2_Open(void *pData)
14350 {
14351 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14352 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14353 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
14354 MS_U32 u32TargetBufferAddrPa = 0;
14355 MS_S32 s32Ret = 0;
14356 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
14357
14358 if (pData == NULL)
14359 {
14360 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14361 return -A_EFAULT;
14362 }
14363
14364 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14365
14366 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14367 {
14368 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);
14369 return -A_EINVAL;
14370 }
14371
14372 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
14373 {
14374 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
14375 return -A_EINVAL;
14376 }
14377
14378 if (pUserPcmInfo->u8MultiChFlag == TRUE)
14379 {
14380 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14381 return -A_EINVAL;
14382 }
14383
14384 if (pUserPcmInfo->u8MixingFlag == TRUE)
14385 {
14386 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14387 return -A_EINVAL;
14388 }
14389
14390 if (pUserPcmInfo->u8CaptureFlag != TRUE)
14391 {
14392 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
14393 return -A_EINVAL;
14394 }
14395
14396 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)
14397 {
14398 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
14399 return -A_EINVAL;
14400 }
14401
14402 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)
14403 {
14404 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
14405 return -A_EINVAL;
14406 }
14407
14408 /* fill in settings */
14409 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14410 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
14411 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
14412 pPcmInfo->u8ConnectFlag = TRUE;
14413 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14414 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14415 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
14416 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
14417 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
14418 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE2_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
14419 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
14420 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
14421 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
14422 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
14423 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
14424 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
14425
14426 /* init PCM buffer address */
14427 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
14428 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
14429 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14430 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14431
14432 /* restart */
14433 HAL_AUDIO_PCM_Capture2_Restart();
14434
14435 return s32Ret;
14436 }
14437
HAL_AUDIO_PCM_Capture2_Close(void)14438 MS_S32 HAL_AUDIO_PCM_Capture2_Close(void)
14439 {
14440 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14441 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14442 MS_S32 s32Ret = 0;
14443 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
14444
14445 if (pPcmInfo->u8ConnectFlag != FALSE)
14446 {
14447 HAL_AUDIO_PCM_Capture2_Flush();
14448 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14449 }
14450
14451 return s32Ret;
14452 }
14453
HAL_AUDIO_PCM_Capture2_Start(void)14454 MS_S32 HAL_AUDIO_PCM_Capture2_Start(void)
14455 {
14456 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14457 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14458 MS_U32 u32BufferSize = 0;
14459 MS_S32 s32Ret = 0;
14460 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
14461
14462 if (pPcmInfo->u8StartFlag == FALSE)
14463 {
14464 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14465 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
14466
14467 pPcmInfo->u8StartFlag = TRUE;
14468 }
14469
14470 return s32Ret;
14471 }
14472
HAL_AUDIO_PCM_Capture2_Stop(void)14473 MS_S32 HAL_AUDIO_PCM_Capture2_Stop(void)
14474 {
14475 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14476 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14477 MS_S32 s32Ret = 0;
14478 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
14479
14480 if (pPcmInfo->u8StartFlag != FALSE)
14481 {
14482 /* TODO, there is no such control in DSP */
14483
14484 pPcmInfo->u8StartFlag = FALSE;
14485 }
14486
14487 return s32Ret;
14488 }
14489
HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd,const void * pData)14490 MS_S32 HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd, const void *pData)
14491 {
14492 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14493 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14494 MS_S32 s32Ret = 0;
14495 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14496
14497 if (pData == NULL)
14498 {
14499 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14500 return -A_EFAULT;
14501 }
14502
14503 if (pPcmInfo->u8ConnectFlag == FALSE)
14504 {
14505 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14506 return -A_EPERM;
14507 }
14508
14509 switch(u32Cmd)
14510 {
14511 case AUDIO_PCM_CMD_NONBLOCKING:
14512 {
14513 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
14514
14515 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
14516 {
14517 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
14518 s32Ret = -A_EINVAL;
14519 break;
14520 }
14521
14522 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
14523
14524 break;
14525 }
14526
14527 case AUDIO_PCM_CMD_MULTICH:
14528 {
14529 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
14530
14531 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
14532 {
14533 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
14534 s32Ret = -A_EINVAL;
14535 break;
14536 }
14537
14538 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
14539 {
14540 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14541 s32Ret = -A_EINVAL;
14542 break;
14543 }
14544
14545 pPcmInfo->u8MultiChFlag = FALSE;
14546
14547 break;
14548 }
14549
14550 case AUDIO_PCM_CMD_MIXING:
14551 {
14552 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
14553
14554 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
14555 {
14556 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
14557 s32Ret = -A_EINVAL;
14558 break;
14559 }
14560
14561 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
14562 {
14563 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14564 s32Ret = -A_EINVAL;
14565 break;
14566 }
14567
14568 pPcmInfo->u8MixingFlag = FALSE;
14569
14570 break;
14571 }
14572
14573 case AUDIO_PCM_CMD_MIXINGGROUP:
14574 {
14575 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
14576
14577 pPcmInfo->u32MixingGroup = u32MixingGroup;
14578
14579 break;
14580 }
14581
14582 case AUDIO_PCM_CMD_BUFFERDURATION:
14583 {
14584 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
14585 s32Ret = -A_EPERM;
14586
14587 break;
14588 }
14589
14590 case AUDIO_PCM_CMD_CHANNEL:
14591 {
14592 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14593 s32Ret = -A_EPERM;
14594
14595 break;
14596 }
14597
14598 case AUDIO_PCM_CMD_SAMPLERATE:
14599 {
14600 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14601 s32Ret = -A_EPERM;
14602
14603 break;
14604 }
14605
14606 case AUDIO_PCM_CMD_BITWIDTH:
14607 {
14608 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14609
14610 pPcmInfo->u32BitWidth = u32BitWidth;
14611
14612 break;
14613 }
14614
14615 case AUDIO_PCM_CMD_BIGENDIAN:
14616 {
14617 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14618
14619 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14620 {
14621 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
14622 return -A_EINVAL;
14623 }
14624
14625 pPcmInfo->u32BigEndian = u32BigEndian;
14626
14627 break;
14628 }
14629
14630 case AUDIO_PCM_CMD_TIMESTAMP:
14631 {
14632 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14633
14634 pPcmInfo->u32Timestamp = u32Timestamp;
14635
14636 break;
14637 }
14638
14639 case AUDIO_PCM_CMD_WEIGHTING:
14640 {
14641 MS_U32 u32Weighting = *((MS_U32 *)pData);
14642
14643 if (u32Weighting > 100)
14644 {
14645 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14646 return -A_EINVAL;
14647 }
14648
14649 pPcmInfo->u32Weighting = u32Weighting;
14650
14651 break;
14652 }
14653
14654 case AUDIO_PCM_CMD_VOLUME:
14655 {
14656 MS_U32 u32Volume = *((MS_U32 *)pData);
14657
14658 if (u32Volume > 100)
14659 {
14660 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14661 return -A_EINVAL;
14662 }
14663
14664 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14665
14666 break;
14667 }
14668
14669 case AUDIO_PCM_CMD_MUTE:
14670 {
14671 MS_U32 u32Mute = *((MS_U32*)pData);
14672
14673 if (u32Mute == TRUE)
14674 {
14675 pPcmInfo->u32Volume |= 0x80000000;
14676 }
14677 else if (u32Mute == FALSE)
14678 {
14679 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14680 }
14681 else
14682 {
14683 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
14684 s32Ret = -A_EINVAL;
14685 }
14686 break;
14687 }
14688
14689 default:
14690 {
14691 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14692 break;
14693 }
14694 }
14695
14696 return s32Ret;
14697 }
14698
HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd,void * pData)14699 MS_S32 HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd, void *pData)
14700 {
14701 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14702 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14703 MS_S32 s32Ret = 0;
14704 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14705
14706 if (pData == NULL)
14707 {
14708 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14709 return -A_EFAULT;
14710 }
14711
14712 if (pPcmInfo->u8ConnectFlag == FALSE)
14713 {
14714 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14715 return -A_EPERM;
14716 }
14717
14718 switch(u32Cmd)
14719 {
14720 case AUDIO_PCM_CMD_ALL:
14721 {
14722 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14723 MS_U32 u32MinSize = 0;
14724
14725 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14726 {
14727 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);
14728 s32Ret = -A_EINVAL;
14729 break;
14730 }
14731 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14732 {
14733 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);
14734 }
14735
14736 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14737 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14738 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14739
14740 break;
14741 }
14742
14743 case AUDIO_PCM_CMD_NONBLOCKING:
14744 {
14745 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14746 break;
14747 }
14748
14749 case AUDIO_PCM_CMD_MULTICH:
14750 {
14751 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14752 break;
14753 }
14754
14755 case AUDIO_PCM_CMD_MIXING:
14756 {
14757 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14758 break;
14759 }
14760
14761 case AUDIO_PCM_CMD_MIXINGGROUP:
14762 {
14763 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14764 break;
14765 }
14766
14767 case AUDIO_PCM_CMD_BUFFER:
14768 {
14769 /*
14770 * TODO, need better coding
14771 *
14772 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14773 */
14774 break;
14775 }
14776
14777 case AUDIO_PCM_CMD_BUFFERDURATION:
14778 {
14779 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14780 break;
14781 }
14782
14783 case AUDIO_PCM_CMD_READPTR:
14784 {
14785 /*
14786 * TODO, need better coding
14787 *
14788 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14789 */
14790 break;
14791 }
14792
14793 case AUDIO_PCM_CMD_WRITEPTR:
14794 {
14795 /*
14796 * TODO, need better coding
14797 *
14798 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14799 */
14800 break;
14801 }
14802
14803 case AUDIO_PCM_CMD_CHANNEL:
14804 {
14805 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14806 break;
14807 }
14808
14809 case AUDIO_PCM_CMD_SAMPLERATE:
14810 {
14811 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14812 break;
14813 }
14814
14815 case AUDIO_PCM_CMD_BITWIDTH:
14816 {
14817 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14818 break;
14819 }
14820
14821 case AUDIO_PCM_CMD_BIGENDIAN:
14822 {
14823 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14824 break;
14825 }
14826
14827 case AUDIO_PCM_CMD_TIMESTAMP:
14828 {
14829 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14830 break;
14831 }
14832
14833 case AUDIO_PCM_CMD_WEIGHTING:
14834 {
14835 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14836 break;
14837 }
14838
14839 case AUDIO_PCM_CMD_VOLUME:
14840 {
14841 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14842 break;
14843 }
14844
14845 case AUDIO_PCM_CMD_BUFFERLEVEL:
14846 {
14847 MS_U32 u32WritePtrOffset = 0;
14848 MS_U32 u32BufferSize = 0;
14849 MS_S32 s32PcmLevel = 0;
14850
14851 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14852 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
14853
14854 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
14855 if (s32PcmLevel < 0)
14856 {
14857 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14858 s32PcmLevel += u32BufferSize;
14859 }
14860
14861 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
14862 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
14863
14864 break;
14865 }
14866
14867 case AUDIO_PCM_CMD_MUTE:
14868 {
14869 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
14870 break;
14871 }
14872
14873 case AUDIO_PCM_CMD_BUFFERSIZE:
14874 {
14875 *((MS_U32 *)pData) = PCM_CAPTURE2_BUF_SIZE;
14876
14877 break;
14878 }
14879
14880 default:
14881 {
14882 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14883 break;
14884 }
14885 }
14886
14887 return s32Ret;
14888 }
14889
HAL_AUDIO_PCM_Capture2_Read(void * pBuf,MS_U32 u32Size)14890 MS_U32 HAL_AUDIO_PCM_Capture2_Read(void *pBuf, MS_U32 u32Size)
14891 {
14892 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14893 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14894 MS_S8 *pBufTmp = NULL;
14895 MS_U32 u32BufferSize = 0;
14896 MS_U32 u32PcmLevel = 0;
14897 MS_U32 u32RequestSize = 0;
14898 MS_U32 u32RequestSizeTmp = 0;
14899 MS_U32 u32SizeToCopy = 0;
14900 MS_U32 u32RptrOffset = 0;
14901 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14902
14903 if (pBuf == NULL)
14904 {
14905 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14906 return 0;
14907 }
14908
14909 if (u32Size == 0)
14910 {
14911 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14912 return 0;
14913 }
14914
14915 if (pPcmInfo->u8ConnectFlag == FALSE)
14916 {
14917 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14918 return 0;
14919 }
14920
14921 if (pPcmInfo->u8StartFlag == FALSE)
14922 {
14923 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
14924 return 0;
14925 }
14926
14927 pBufTmp = (MS_S8 *)pBuf;
14928
14929 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14930 HAL_AUDIO_PCM_Capture2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14931 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE2_BUF_UNIT))
14932 {
14933 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
14934
14935 u32PcmLevel = 0;
14936 HAL_AUDIO_PCM_Capture2_Stop();
14937 HAL_AUDIO_PCM_Capture2_Restart();
14938 HAL_AUDIO_PCM_Capture2_Start();
14939 }
14940
14941 u32RequestSize = u32Size;
14942 u32RequestSizeTmp = u32RequestSize;
14943
14944 /* copy data from PCM buffer */
14945 if (u32PcmLevel >= u32RequestSize)
14946 {
14947 do {
14948 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
14949 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14950
14951 #ifdef MSOS_TYPE_LINUX_KERNEL
14952 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14953 #else
14954 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14955 #endif
14956
14957 pBufTmp += u32SizeToCopy;
14958 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
14959 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14960 {
14961 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14962 {
14963 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14964 }
14965 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14966 }
14967
14968 u32RequestSizeTmp -= u32SizeToCopy;
14969 } while (u32RequestSizeTmp > 0);
14970
14971 /* flush MIU */
14972 MsOS_FlushMemory();
14973
14974 /* update read pointer to engine */
14975 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
14976 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
14977
14978 return u32Size;
14979 }
14980
14981 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14982
14983 return 0;
14984 }
14985
HAL_AUDIO_PCM_Capture2_Flush(void)14986 MS_S32 HAL_AUDIO_PCM_Capture2_Flush(void)
14987 {
14988 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14989 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14990 MS_S32 s32Ret = 0;
14991 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14992
14993 if (pPcmInfo->u8StartFlag == FALSE)
14994 {
14995 HAL_AUDIO_PCM_Capture2_Restart();
14996 HAL_AUDIO_PCM_Capture2_Stop();
14997 }
14998
14999 return s32Ret;
15000 }
15001 #endif
15002
15003 #if AUDIO_HW_DMA_WRITER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)15004 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)
15005 {
15006 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15007 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15008 //MS_U32 u32WritePtrOffset = 0;
15009 //MS_U32 u32TimeoutCounter = 0;
15010 MS_S32 s32Ret = 0;
15011
15012 if (pPcmInfo->u8ConnectFlag == FALSE)
15013 {
15014 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15015 return -A_EPERM;
15016 }
15017
15018 /* clear PCM buffer */
15019 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_WTR1_BUF_SIZE);
15020
15021 /* flush MIU */
15022 MsOS_FlushMemory();
15023 return s32Ret;
15024 }
15025
HAL_AUDIO_PCM_HwDma_Writer1_Open(void * pData)15026 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Open(void *pData)
15027 {
15028 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15029 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15030 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
15031 MS_U32 u32TargetBufferAddrPa = 0;
15032 MS_U32 u32TargetBufferSize = 0;
15033 MS_U32 u32TargetChannel = 0;
15034 MS_U32 u32TargetBitWidth = 0;
15035 MS_U32 u32TargetAlignmentSize = 0;
15036 MS_S32 s32Ret = 0;
15037 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
15038
15039 if (pData == NULL)
15040 {
15041 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15042 return -A_EFAULT;
15043 }
15044
15045 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
15046
15047 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
15048 {
15049 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);
15050 return -A_EINVAL;
15051 }
15052
15053 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
15054 {
15055 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, (MS_U32)sizeof(AUDIO_PCM_INFO_t));
15056 return -A_EINVAL;
15057 }
15058
15059 if (pUserPcmInfo->u8MultiChFlag == TRUE)
15060 {
15061 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
15062 return -A_EINVAL;
15063 }
15064
15065 if (pUserPcmInfo->u8MixingFlag == TRUE)
15066 {
15067 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
15068 return -A_EINVAL;
15069 }
15070
15071 if (pUserPcmInfo->u8CaptureFlag != TRUE)
15072 {
15073 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
15074 return -A_EINVAL;
15075 }
15076
15077 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)
15078 {
15079 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
15080 return -A_EINVAL;
15081 }
15082
15083 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)
15084 {
15085 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
15086 return -A_EINVAL;
15087 }
15088
15089 /* fill in settings */
15090 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
15091 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
15092 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
15093 pPcmInfo->u8ConnectFlag = TRUE;
15094 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
15095 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
15096
15097 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
15098 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
15099 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
15100 pPcmInfo->u32BufferDuration = ((HW_DMA_WTR1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
15101 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
15102 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;;
15103 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
15104 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
15105 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
15106 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
15107
15108 /* init PCM buffer address */
15109 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR;
15110 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
15111 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15112 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
15113
15114 /* set PCM buffer address */
15115 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
15116 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE) & 0xFFFF);
15117 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
15118
15119 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x80, 0x80);
15120 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x0F, M2S_MBOX_GET_Raw);
15121
15122 /* calculate buffer size */
15123 u32TargetChannel = 2;
15124 u32TargetBitWidth = 16;
15125 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
15126 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
15127 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
15128 if (u32TargetBufferSize > HW_DMA_WTR1_BUF_SIZE)
15129 {
15130 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);
15131 u32TargetBufferSize = HW_DMA_WTR1_BUF_SIZE;
15132 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
15133 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
15134 }
15135
15136 /* set buffer size */
15137 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
15138 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
15139
15140 /* Reset and Start DMA Writer */
15141 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
15142 AUDIO_DELAY1US(1);
15143 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
15144
15145 /* restart */
15146 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
15147
15148 return s32Ret;
15149 }
15150
HAL_AUDIO_PCM_HwDma_Writer1_Close(void)15151 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Close(void)
15152 {
15153 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15154 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15155 MS_S32 s32Ret = 0;
15156 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
15157
15158 if (pPcmInfo->u8ConnectFlag != FALSE)
15159 {
15160 HAL_AUDIO_PCM_HwDma_Writer1_Flush();
15161 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
15162 }
15163
15164 return s32Ret;
15165 }
15166
HAL_AUDIO_PCM_HwDma_Writer1_Start(void)15167 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Start(void)
15168 {
15169 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15170 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15171 //MS_U32 u32BufferSize = 0;
15172 MS_S32 s32Ret = 0;
15173 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
15174
15175 if (pPcmInfo->u8StartFlag == FALSE)
15176 {
15177 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0001);
15178 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0002);
15179
15180 pPcmInfo->u8StartFlag = TRUE;
15181 }
15182
15183 return s32Ret;
15184 }
15185
HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)15186 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)
15187 {
15188 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15189 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15190 MS_S32 s32Ret = 0;
15191 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
15192
15193 if (pPcmInfo->u8StartFlag != FALSE)
15194 {
15195 /* TODO, there is no such control in DSP */
15196
15197 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0000);
15198 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0000);
15199
15200 pPcmInfo->u8StartFlag = FALSE;
15201 }
15202
15203 return s32Ret;
15204 }
15205
HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd,const void * pData)15206 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd, const void *pData)
15207 {
15208 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15209 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15210 MS_S32 s32Ret = 0;
15211 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15212
15213 if (pData == NULL)
15214 {
15215 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15216 return -A_EFAULT;
15217 }
15218
15219 if (pPcmInfo->u8ConnectFlag == FALSE)
15220 {
15221 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15222 return -A_EPERM;
15223 }
15224
15225 switch(u32Cmd)
15226 {
15227 case AUDIO_PCM_CMD_NONBLOCKING:
15228 {
15229 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
15230
15231 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
15232 {
15233 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
15234 s32Ret = -A_EINVAL;
15235 break;
15236 }
15237
15238 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
15239
15240 break;
15241 }
15242
15243 case AUDIO_PCM_CMD_MULTICH:
15244 {
15245 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
15246
15247 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
15248 {
15249 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
15250 s32Ret = -A_EINVAL;
15251 break;
15252 }
15253
15254 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
15255 {
15256 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
15257 s32Ret = -A_EINVAL;
15258 break;
15259 }
15260
15261 pPcmInfo->u8MultiChFlag = FALSE;
15262
15263 break;
15264 }
15265
15266 case AUDIO_PCM_CMD_MIXING:
15267 {
15268 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
15269
15270 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
15271 {
15272 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
15273 s32Ret = -A_EINVAL;
15274 break;
15275 }
15276
15277 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
15278 {
15279 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
15280 s32Ret = -A_EINVAL;
15281 break;
15282 }
15283
15284 pPcmInfo->u8MixingFlag = FALSE;
15285
15286 break;
15287 }
15288
15289 case AUDIO_PCM_CMD_MIXINGGROUP:
15290 {
15291 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
15292
15293 pPcmInfo->u32MixingGroup = u32MixingGroup;
15294
15295 break;
15296 }
15297
15298 case AUDIO_PCM_CMD_BUFFERDURATION:
15299 {
15300 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
15301
15302 if (u32BufferDuration == 0)
15303 {
15304 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
15305 s32Ret = -A_EINVAL;
15306 break;
15307 }
15308
15309 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
15310 {
15311 pPcmInfo->u32BufferDuration = u32BufferDuration;
15312 pPCM->u8SettingChangeFlag = TRUE;
15313 }
15314
15315 break;
15316 }
15317
15318 case AUDIO_PCM_CMD_CHANNEL:
15319 {
15320 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
15321 s32Ret = -A_EPERM;
15322
15323 break;
15324 }
15325
15326 case AUDIO_PCM_CMD_SAMPLERATE:
15327 {
15328 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
15329 s32Ret = -A_EPERM;
15330
15331 break;
15332 }
15333
15334 case AUDIO_PCM_CMD_BITWIDTH:
15335 {
15336 MS_U32 u32BitWidth = *((MS_U32 *)pData);
15337
15338 pPcmInfo->u32BitWidth = u32BitWidth;
15339
15340 break;
15341 }
15342
15343 case AUDIO_PCM_CMD_BIGENDIAN:
15344 {
15345 MS_U32 u32BigEndian = *((MS_U32 *)pData);
15346
15347 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
15348 {
15349 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
15350 return -A_EINVAL;
15351 }
15352
15353 pPcmInfo->u32BigEndian = u32BigEndian;
15354
15355 break;
15356 }
15357
15358 case AUDIO_PCM_CMD_TIMESTAMP:
15359 {
15360 MS_U32 u32Timestamp = *((MS_U32 *)pData);
15361
15362 pPcmInfo->u32Timestamp = u32Timestamp;
15363
15364 break;
15365 }
15366
15367 case AUDIO_PCM_CMD_WEIGHTING:
15368 {
15369 MS_U32 u32Weighting = *((MS_U32 *)pData);
15370
15371 if (u32Weighting > 100)
15372 {
15373 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
15374 return -A_EINVAL;
15375 }
15376
15377 pPcmInfo->u32Weighting = u32Weighting;
15378
15379 break;
15380 }
15381
15382 case AUDIO_PCM_CMD_VOLUME:
15383 {
15384 MS_U32 u32Volume = *((MS_U32 *)pData);
15385
15386 if (u32Volume > 100)
15387 {
15388 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
15389 return -A_EINVAL;
15390 }
15391
15392 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
15393
15394 break;
15395 }
15396
15397 case AUDIO_PCM_CMD_MUTE:
15398 {
15399 MS_U32 u32Mute = *((MS_U32*)pData);
15400
15401 if (u32Mute == TRUE)
15402 {
15403 pPcmInfo->u32Volume |= 0x80000000;
15404 }
15405 else if (u32Mute == FALSE)
15406 {
15407 pPcmInfo->u32Volume &= 0x7FFFFFFF;
15408 }
15409 else
15410 {
15411 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
15412 s32Ret = -A_EINVAL;
15413 }
15414 break;
15415 }
15416
15417 default:
15418 {
15419 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
15420 break;
15421 }
15422 }
15423
15424 return s32Ret;
15425 }
15426
HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd,void * pData)15427 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd, void *pData)
15428 {
15429 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15430 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15431 MS_S32 s32Ret = 0;
15432 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15433
15434 if (pData == NULL)
15435 {
15436 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15437 return -A_EFAULT;
15438 }
15439
15440 if (pPcmInfo->u8ConnectFlag == FALSE)
15441 {
15442 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15443 return -A_EPERM;
15444 }
15445
15446 switch(u32Cmd)
15447 {
15448 case AUDIO_PCM_CMD_ALL:
15449 {
15450 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
15451 MS_U32 u32MinSize = 0;
15452
15453 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
15454 {
15455 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);
15456 s32Ret = -A_EINVAL;
15457 break;
15458 }
15459 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
15460 {
15461 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);
15462 }
15463
15464 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
15465 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
15466 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
15467
15468 break;
15469 }
15470
15471 case AUDIO_PCM_CMD_NONBLOCKING:
15472 {
15473 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
15474 break;
15475 }
15476
15477 case AUDIO_PCM_CMD_MULTICH:
15478 {
15479 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
15480 break;
15481 }
15482
15483 case AUDIO_PCM_CMD_MIXING:
15484 {
15485 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
15486 break;
15487 }
15488
15489 case AUDIO_PCM_CMD_MIXINGGROUP:
15490 {
15491 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
15492 break;
15493 }
15494
15495 case AUDIO_PCM_CMD_BUFFER:
15496 {
15497 /*
15498 * TODO, need better coding
15499 *
15500 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
15501 */
15502 break;
15503 }
15504
15505 case AUDIO_PCM_CMD_BUFFERDURATION:
15506 {
15507 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
15508 break;
15509 }
15510
15511 case AUDIO_PCM_CMD_READPTR:
15512 {
15513 /*
15514 * TODO, need better coding
15515 *
15516 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
15517 */
15518 break;
15519 }
15520
15521 case AUDIO_PCM_CMD_WRITEPTR:
15522 {
15523 /*
15524 * TODO, need better coding
15525 *
15526 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
15527 */
15528 break;
15529 }
15530
15531 case AUDIO_PCM_CMD_CHANNEL:
15532 {
15533 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
15534 break;
15535 }
15536
15537 case AUDIO_PCM_CMD_SAMPLERATE:
15538 {
15539 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
15540 break;
15541 }
15542
15543 case AUDIO_PCM_CMD_BITWIDTH:
15544 {
15545 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
15546 break;
15547 }
15548
15549 case AUDIO_PCM_CMD_BIGENDIAN:
15550 {
15551 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
15552 break;
15553 }
15554
15555 case AUDIO_PCM_CMD_TIMESTAMP:
15556 {
15557 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
15558 break;
15559 }
15560
15561 case AUDIO_PCM_CMD_WEIGHTING:
15562 {
15563 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
15564 break;
15565 }
15566
15567 case AUDIO_PCM_CMD_VOLUME:
15568 {
15569 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
15570 break;
15571 }
15572
15573 case AUDIO_PCM_CMD_BUFFERLEVEL:
15574 {
15575 MS_U32 u32BufferLevel1 = 0;
15576 MS_U32 u32BufferLevel2 = 0;
15577 MS_U32 u32Timeout = 20;
15578
15579 while (u32Timeout > 0)
15580 {
15581 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
15582 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
15583
15584 if (u32BufferLevel1 == u32BufferLevel2)
15585 {
15586 break;
15587 }
15588
15589 u32Timeout--;
15590
15591 #ifdef MSOS_TYPE_LINUX_KERNEL
15592 udelay(1);
15593 #else
15594 AUDIO_DELAY1US(1);
15595 #endif
15596 }
15597
15598 if (u32BufferLevel1 != u32BufferLevel2)
15599 {
15600 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
15601 }
15602
15603 pPcmInfo->u32BufferLevel = u32BufferLevel2;
15604 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
15605
15606 break;
15607 }
15608
15609 case AUDIO_PCM_CMD_MUTE:
15610 {
15611 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
15612 break;
15613 }
15614
15615 case AUDIO_PCM_CMD_BUFFERSIZE:
15616 {
15617 *((MS_U32 *)pData) = HW_DMA_WTR1_BUF_SIZE;
15618
15619 break;
15620 }
15621
15622 default:
15623 {
15624 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
15625 break;
15626 }
15627 }
15628
15629 return s32Ret;
15630 }
15631
HAL_AUDIO_PCM_HwDma_Writer1_Read(void * pBuf,MS_U32 u32Size)15632 MS_U32 HAL_AUDIO_PCM_HwDma_Writer1_Read(void *pBuf, MS_U32 u32Size)
15633 {
15634 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15635 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15636 MS_S8 *pBufTmp = NULL;
15637 MS_U32 u32BufferSize = 0;
15638 MS_U32 u32PcmLevel = 0;
15639 MS_U32 u32RequestSize = 0;
15640 MS_U32 u32RequestSizeTmp = 0;
15641 MS_U32 u32SizeToCopy = 0;
15642 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
15643
15644 if (pBuf == NULL)
15645 {
15646 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
15647 return 0;
15648 }
15649
15650 if (u32Size == 0)
15651 {
15652 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
15653 return 0;
15654 }
15655
15656 if (pPcmInfo->u8ConnectFlag == FALSE)
15657 {
15658 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15659 return 0;
15660 }
15661
15662 if (pPcmInfo->u8StartFlag == FALSE)
15663 {
15664 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
15665 return 0;
15666 }
15667
15668 pBufTmp = (MS_S8 *)pBuf;
15669
15670 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15671 HAL_AUDIO_PCM_HwDma_Writer1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
15672
15673 u32RequestSize = u32Size;
15674 u32RequestSizeTmp = u32RequestSize;
15675
15676 /* copy data from PCM buffer */
15677 if (u32PcmLevel >= u32RequestSize)
15678 {
15679 do {
15680 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
15681 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
15682
15683 #ifdef MSOS_TYPE_LINUX_KERNEL
15684 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15685 #else
15686 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15687 #endif
15688
15689 pBufTmp += u32SizeToCopy;
15690 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
15691 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15692 {
15693 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15694 {
15695 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
15696 }
15697 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15698 }
15699
15700 u32RequestSizeTmp -= u32SizeToCopy;
15701 } while (u32RequestSizeTmp > 0);
15702
15703 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
15704 HAL_AUR2_WriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
15705 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
15706
15707 return u32Size;
15708 }
15709 return 0;
15710 }
15711
HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)15712 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)
15713 {
15714 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15715 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15716 MS_S32 s32Ret = 0;
15717 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
15718
15719 if (pPcmInfo->u8StartFlag == FALSE)
15720 {
15721 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
15722 HAL_AUDIO_PCM_HwDma_Writer1_Stop();
15723 }
15724
15725 return s32Ret;
15726 }
15727 #endif
15728
HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)15729 AUDIO_DSP_CODE_TYPE HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)
15730 {
15731 AUDIO_DSP_CODE_TYPE dspCodeType = AU_DVB_STANDARD_INVALID;
15732
15733 switch (enDecSystem)
15734 {
15735 case MSAPI_AUD_ATV_BTSC:
15736 dspCodeType = AU_SIF_BTSC;
15737 break;
15738 case MSAPI_AUD_ATV_PAL:
15739 dspCodeType = AU_SIF_PALSUM;
15740 break;
15741 case MSAPI_AUD_DVB_MPEG:
15742 dspCodeType = AU_DVB_STANDARD_MPEG;
15743 break;
15744 case MSAPI_AUD_DVB_AC3:
15745 dspCodeType = AU_DVB_STANDARD_AC3;
15746 break;
15747 case MSAPI_AUD_DVB_AC3P:
15748 dspCodeType = AU_DVB_STANDARD_AC3P;
15749 break;
15750 case MSAPI_AUD_DVB_AAC:
15751 dspCodeType = AU_DVB_STANDARD_AAC;
15752 break;
15753 case MSAPI_AUD_DVB_MP3:
15754 dspCodeType = AU_DVB_STANDARD_MP3;
15755 break;
15756 case MSAPI_AUD_DVB_WMA:
15757 dspCodeType = AU_DVB_STANDARD_WMA;
15758 break;
15759 case MSAPI_AUD_DVB_RA8LBR:
15760 dspCodeType = AU_DVB_STANDARD_RA8LBR;
15761 break;
15762 case MSAPI_AUD_DVB_XPCM:
15763 dspCodeType = AU_DVB_STANDARD_XPCM;
15764 break;
15765 case MSAPI_AUD_DVB_DTS:
15766 dspCodeType = AU_DVB_STANDARD_DTS;
15767 break;
15768 case MSAPI_AUD_DVB_MS10_DDT:
15769 dspCodeType = AU_DVB_STANDARD_MS10_DDT;
15770 break;
15771 case MSAPI_AUD_DVB_MS10_DDC:
15772 dspCodeType = AU_DVB_STANDARD_MS10_DDC;
15773 break;
15774 case MSAPI_AUD_DVB_WMA_PRO:
15775 dspCodeType = AU_DVB_STANDARD_WMA_PRO;
15776 break;
15777 case MSAPI_AUD_DVB_FLAC:
15778 dspCodeType = AU_DVB_STANDARD_FLAC;
15779 break;
15780 case MSAPI_AUD_DVB_VORBIS:
15781 dspCodeType = AU_DVB_STANDARD_VORBIS;
15782 break;
15783 case MSAPI_AUD_DVB_DTSLBR:
15784 dspCodeType = AU_DVB_STANDARD_DTSLBR;
15785 break;
15786 case MSAPI_AUD_DVB_DRA:
15787 dspCodeType = AU_DVB_STANDARD_DRA;
15788 break;
15789 default:
15790 break;
15791 }
15792
15793 return dspCodeType;
15794 }
15795
HAL_AUDIO_ResetDspCodeType(void)15796 void HAL_AUDIO_ResetDspCodeType(void)
15797 {
15798 g_AudioVars2->g_DspCodeType = AU_DVB_STANDARD_INVALID;
15799 g_AudioVars2->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
15800 g_AudioVars2->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
15801 }
15802
HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)15803 MS_S32 HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)
15804 {
15805 return 0;
15806 }
15807
15808 ////////////////////////////////////////////////////////////////////////////////
15809 /// @brief \b Function \b Name: HAL_AUDIO_DMIOReset()
15810 /// @brief \b Function \b Description: This function is used to do hw DMIO reset
15811 /// @param <IN> \b NONE :
15812 /// @param <OUT> \b NONE :
15813 /// @param <RET> \b NONE :
15814 /// @param <GLOBAL> \b NONE :
15815 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DMIOReset(void)15816 void HAL_AUDIO_DMIOReset(void)
15817 {
15818 HAL_AUDIO_WriteMaskByte(REG_MAD_DMA_IDLE_RESET, 0x01, 0x01);
15819 MsOS_DelayTask(1);
15820 HAL_AUDIO_WriteMaskByte(REG_MAD_DMA_IDLE_RESET, 0x01, 0x00);
15821
15822 HAL_AUDIO_WriteMaskByte(REG_SE_DMA_IDLE_RESET, 0x01, 0x01);
15823 MsOS_DelayTask(1);
15824 HAL_AUDIO_WriteMaskByte(REG_SE_DMA_IDLE_RESET, 0x01, 0x00);
15825 }
15826
HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)15827 MS_S32 HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)
15828 {
15829 MS_U8 u8PcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
15830
15831 HALAUDIO_CHECK_SHM_INIT;
15832
15833 switch (enGroup)
15834 {
15835 case E_AUDIO_GROUP_MAIN:
15836 {
15837 switch (g_AudioVars2->eAudioSource)
15838 {
15839 case E_AUDIO_INFO_DTV_IN:
15840 case E_AUDIO_INFO_MM_IN:
15841 case E_AUDIO_INFO_GAME_IN:
15842 {
15843 u8PcmRenderControl = 0; //decoder mode
15844 break;
15845 }
15846
15847 case E_AUDIO_INFO_ATV_IN:
15848 case E_AUDIO_INFO_HDMI_IN:
15849 case E_AUDIO_INFO_ADC_IN:
15850 case E_AUDIO_INFO_SPDIF_IN:
15851 case E_AUDIO_INFO_KTV_IN:
15852 case E_AUDIO_INFO_KTV_STB_IN:
15853 default:
15854 {
15855 u8PcmRenderControl = 2; //stereo mode
15856 break;
15857 }
15858 }
15859
15860 /* configure a default setting to R2's PCM Render accroding to current input source */
15861 printf("%s() enGroup:%x eAudioSource:%x u8PcmRenderControl << 1=%d\n", __FUNCTION__, enGroup,g_AudioVars2->eAudioSource,u8PcmRenderControl << 1);
15862 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8PcmRenderControl << 1));
15863
15864 break;
15865 }
15866
15867 default:
15868 {
15869 break;
15870 }
15871 }
15872
15873 return 0;
15874 }
15875
HAL_AUDIO_MP3_ENCODER1_Open(void)15876 MS_S32 HAL_AUDIO_MP3_ENCODER1_Open(void)
15877 {
15878 #if AUDIO_MP3_ENCODER1_SUPPORT
15879 MS_S32 s32Ret = 0;
15880
15881 /* enable MP3 Encoder1 */
15882 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x01, 0x01);
15883
15884 HAL_AUDIO_MP3_ENCODER1_Stop();
15885
15886 /* reset read pointer */
15887 g_u32Mp3Encoder1RptrOffset = 0;
15888 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
15889
15890 return s32Ret;
15891 #else
15892 return 0;
15893 #endif
15894 }
15895
HAL_AUDIO_MP3_ENCODER1_Close(void)15896 MS_S32 HAL_AUDIO_MP3_ENCODER1_Close(void)
15897 {
15898 #if AUDIO_MP3_ENCODER1_SUPPORT
15899 MS_S32 s32Ret = 0;
15900
15901 HAL_AUDIO_MP3_ENCODER1_Flush();
15902
15903 /* disable MP3 Encoder1 */
15904 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x01, 0x00);
15905
15906 return s32Ret;
15907 #else
15908 return 0;
15909 #endif
15910 }
15911
HAL_AUDIO_MP3_ENCODER1_Start(void)15912 MS_S32 HAL_AUDIO_MP3_ENCODER1_Start(void)
15913 {
15914 #if AUDIO_MP3_ENCODER1_SUPPORT
15915 MS_S32 s32Ret = 0;
15916
15917 /* start MP3 Encoder1 */
15918 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x02, 0x02);
15919
15920 return s32Ret;
15921 #else
15922 return 0;
15923 #endif
15924 }
15925
HAL_AUDIO_MP3_ENCODER1_Stop(void)15926 MS_S32 HAL_AUDIO_MP3_ENCODER1_Stop(void)
15927 {
15928 #if AUDIO_MP3_ENCODER1_SUPPORT
15929 MS_S32 s32Ret = 0;
15930
15931 /* stop MP3 Encoder1 */
15932 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x02, 0x00);
15933
15934 return s32Ret;
15935 #else
15936 return 0;
15937 #endif
15938 }
15939
HAL_AUDIO_MP3_ENCODER1_Ioctl(MS_U32 u32Cmd,void * pData)15940 MS_S32 HAL_AUDIO_MP3_ENCODER1_Ioctl(MS_U32 u32Cmd, void *pData)
15941 {
15942 #if AUDIO_MP3_ENCODER1_SUPPORT
15943 MS_U8 u8DeviceId = 0;
15944 MS_S32 s32Ret = 0;
15945
15946 if (pData == NULL)
15947 {
15948 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15949 return -A_EFAULT;
15950 }
15951
15952 switch (u32Cmd)
15953 {
15954 case AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET:
15955 {
15956 HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_MP3_ENCODER_READ_PTR, u8DeviceId, *((MS_U32 *)pData), 0);
15957 break;
15958 }
15959
15960 case AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET:
15961 {
15962 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_WRITE_PTR, u8DeviceId);
15963 break;
15964 }
15965
15966 case AUDIO_ENCODER_IOCTL_GET_THRESHOLD:
15967 {
15968 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_THRESHOLD, u8DeviceId);
15969 break;
15970 }
15971
15972 case AUDIO_ENCODER_IOCTL_GET_FRAME_SIZE:
15973 {
15974 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_SIZE, u8DeviceId);
15975 break;
15976 }
15977
15978 case AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE:
15979 {
15980 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_AVAILABLE_SIZE, u8DeviceId);
15981 break;
15982 }
15983
15984 case AUDIO_ENCODER_IOCTL_GET_FRAME_COUNT:
15985 {
15986 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_COUNT, u8DeviceId);
15987 break;
15988 }
15989
15990 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_HIGH32BIT:
15991 {
15992 MS_U32 u32Data = 0;
15993
15994 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
15995 u32Data = (u32Data & 0x80000000) >> 31;
15996 *((MS_U32 *)pData) = u32Data;
15997 break;
15998 }
15999
16000 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_LOW32BIT:
16001 {
16002 MS_U32 u32Data = 0;
16003
16004 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16005 u32Data = (u32Data << 1) & 0xFFFFFFFF;
16006 *((MS_U32 *)pData) = u32Data;
16007 break;
16008 }
16009
16010 default:
16011 {
16012 s32Ret = -A_EINVAL;
16013 break;
16014 }
16015 }
16016
16017 return s32Ret;
16018 #else
16019 return 0;
16020 #endif
16021 }
16022
HAL_AUDIO_MP3_ENCODER1_Read(void * pBuf,MS_U32 u32Size)16023 MS_U32 HAL_AUDIO_MP3_ENCODER1_Read(void *pBuf, MS_U32 u32Size)
16024 {
16025 #if AUDIO_MP3_ENCODER1_SUPPORT
16026 MS_S8 *pEncoderBuf = NULL;
16027 MS_S8 *pEncoderReadPtr = NULL;
16028 MS_S8 *pBufTmp = NULL;
16029 MS_U32 u32TargetBufferAddrPa = 0;
16030 MS_U32 u32BufferSize = 0;
16031 MS_U32 u32Mp3Level = 0;
16032 MS_U32 u32RequestSize = 0;
16033 MS_U32 u32RequestSizeTmp = 0;
16034 MS_U32 u32SizeToCopy = 0;
16035 MS_U32 u32Threshold = 0;
16036 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Read %u bytes from %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
16037
16038 if (pBuf == NULL)
16039 {
16040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
16041 return 0;
16042 }
16043
16044 if (u32Size == 0)
16045 {
16046 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
16047 return 0;
16048 }
16049
16050 pBufTmp = (MS_S8 *)pBuf;
16051
16052 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + MP3_ENCODER1_BUF_ADDR;
16053 pEncoderBuf = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
16054 if (pEncoderBuf == NULL)
16055 {
16056 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pEncoderBuf should not be NULL!\n", __FUNCTION__);
16057 return 0;
16058 }
16059
16060 u32BufferSize = MP3_ENCODER1_BUF_SIZE;
16061 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE, &u32Mp3Level);
16062 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_THRESHOLD, &u32Threshold);
16063 if (u32Mp3Level >= (u32BufferSize - u32Threshold))
16064 {
16065 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer full!\n", __FUNCTION__);
16066
16067 u32Mp3Level = 0;
16068 HAL_AUDIO_MP3_ENCODER1_Stop();
16069 HAL_AUDIO_MP3_ENCODER1_Flush();
16070 HAL_AUDIO_MP3_ENCODER1_Start();
16071 }
16072 else if (u32Mp3Level == 0)
16073 {
16074 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16075 }
16076
16077 u32RequestSize = u32Size;
16078 u32RequestSizeTmp = u32RequestSize;
16079
16080 pEncoderReadPtr = pEncoderBuf + g_u32Mp3Encoder1RptrOffset;
16081
16082 //HALAUDIO_ERROR("[%u] %s: u32BufferSize %u, u32Threshold %u, u32Mp3Level %u, u32RequestSize %u\n", MsOS_GetSystemTime(), __FUNCTION__, u32BufferSize, u32Threshold, u32Mp3Level, u32RequestSize);
16083
16084 if (u32Mp3Level <= u32Threshold)
16085 {
16086 return 0;
16087 }
16088 u32Mp3Level -= u32Threshold;
16089
16090 /* copy data from PCM buffer */
16091 if (u32Mp3Level >= u32RequestSize)
16092 {
16093 do {
16094 u32SizeToCopy = (pEncoderBuf + u32BufferSize) - pEncoderReadPtr;
16095 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
16096
16097 /* read MIU */
16098 MsOS_ReadMemory();
16099
16100 #ifdef MSOS_TYPE_LINUX_KERNEL
16101 memcpy_toio((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16102 #else
16103 memcpy((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16104 #endif
16105 //HALAUDIO_ERROR("[%u] %s: g_u32Mp3Encoder1RptrOffset 0x%08X, SizeToCopy %u, ReadPtr 0x%08X, Buf 0x%08X, BufEnd 0x%08X\n", MsOS_GetSystemTime(), __FUNCTION__, g_u32Mp3Encoder1RptrOffset, u32SizeToCopy, pEncoderReadPtr, pEncoderBuf, (pEncoderBuf + u32BufferSize));
16106
16107 pBufTmp += u32SizeToCopy;
16108 pEncoderReadPtr += u32SizeToCopy;
16109 if (pEncoderReadPtr >= (pEncoderBuf + u32BufferSize))
16110 {
16111 if (pEncoderReadPtr > (pEncoderBuf + u32BufferSize))
16112 {
16113 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
16114 }
16115 pEncoderReadPtr = pEncoderBuf;
16116 }
16117
16118 u32RequestSizeTmp -= u32SizeToCopy;
16119 } while (u32RequestSizeTmp > 0);
16120
16121 /* flush MIU */
16122 MsOS_FlushMemory();
16123
16124 /* update read pointer to engine */
16125 g_u32Mp3Encoder1RptrOffset = pEncoderReadPtr - pEncoderBuf;
16126 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
16127
16128 return u32Size;
16129 }
16130
16131 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16132
16133 return 0;
16134 #else
16135 return 0;
16136 #endif
16137 }
16138
HAL_AUDIO_MP3_ENCODER1_Flush(void)16139 MS_S32 HAL_AUDIO_MP3_ENCODER1_Flush(void)
16140 {
16141 #if AUDIO_MP3_ENCODER1_SUPPORT
16142 MS_U32 u32WptrOffset = 0;
16143 MS_S32 s32Ret = 0;
16144
16145 /* set read pointer as write pointer to flush data in buffer */
16146 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET, &u32WptrOffset);
16147 g_u32Mp3Encoder1RptrOffset = u32WptrOffset;
16148 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
16149
16150 return s32Ret;
16151 #else
16152 return 0;
16153 #endif
16154 }
16155
HAL_AUDIO_MP3_ENCODER2_Open(void)16156 MS_S32 HAL_AUDIO_MP3_ENCODER2_Open(void)
16157 {
16158 #if AUDIO_MP3_ENCODER2_SUPPORT
16159 MS_S32 s32Ret = 0;
16160
16161 /* enable MP3 Encoder2 */
16162 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x04, 0x04);
16163
16164 HAL_AUDIO_MP3_ENCODER2_Stop();
16165
16166 /* reset read pointer */
16167 g_u32Mp3Encoder2RptrOffset = 0;
16168 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16169
16170 return s32Ret;
16171 #else
16172 return 0;
16173 #endif
16174 }
16175
HAL_AUDIO_MP3_ENCODER2_Close(void)16176 MS_S32 HAL_AUDIO_MP3_ENCODER2_Close(void)
16177 {
16178 #if AUDIO_MP3_ENCODER2_SUPPORT
16179 MS_S32 s32Ret = 0;
16180
16181 HAL_AUDIO_MP3_ENCODER2_Flush();
16182
16183 /* disable MP3 Encoder2 */
16184 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x04, 0x00);
16185
16186 return s32Ret;
16187 #else
16188 return 0;
16189 #endif
16190 }
16191
HAL_AUDIO_MP3_ENCODER2_Start(void)16192 MS_S32 HAL_AUDIO_MP3_ENCODER2_Start(void)
16193 {
16194 #if AUDIO_MP3_ENCODER2_SUPPORT
16195 MS_S32 s32Ret = 0;
16196
16197 /* start MP3 Encoder2 */
16198 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x08, 0x08);
16199
16200 return s32Ret;
16201 #else
16202 return 0;
16203 #endif
16204 }
16205
HAL_AUDIO_MP3_ENCODER2_Stop(void)16206 MS_S32 HAL_AUDIO_MP3_ENCODER2_Stop(void)
16207 {
16208 #if AUDIO_MP3_ENCODER2_SUPPORT
16209 MS_S32 s32Ret = 0;
16210
16211 /* stop MP3 Encoder2 */
16212 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x08, 0x00);
16213
16214 return s32Ret;
16215 #else
16216 return 0;
16217 #endif
16218 }
16219
HAL_AUDIO_MP3_ENCODER2_Ioctl(MS_U32 u32Cmd,void * pData)16220 MS_S32 HAL_AUDIO_MP3_ENCODER2_Ioctl(MS_U32 u32Cmd, void *pData)
16221 {
16222 #if AUDIO_MP3_ENCODER2_SUPPORT
16223 MS_U8 u8DeviceId = 1;
16224 MS_S32 s32Ret = 0;
16225
16226 if (pData == NULL)
16227 {
16228 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
16229 return -A_EFAULT;
16230 }
16231
16232 switch (u32Cmd)
16233 {
16234 case AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET:
16235 {
16236 HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_MP3_ENCODER_READ_PTR, u8DeviceId, *((MS_U32 *)pData), 0);
16237 break;
16238 }
16239
16240 case AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET:
16241 {
16242 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_WRITE_PTR, u8DeviceId);
16243 break;
16244 }
16245
16246 case AUDIO_ENCODER_IOCTL_GET_THRESHOLD:
16247 {
16248 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_THRESHOLD, u8DeviceId);
16249 break;
16250 }
16251
16252 case AUDIO_ENCODER_IOCTL_GET_FRAME_SIZE:
16253 {
16254 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_SIZE, u8DeviceId);
16255 break;
16256 }
16257
16258 case AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE:
16259 {
16260 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_AVAILABLE_SIZE, u8DeviceId);
16261 break;
16262 }
16263
16264 case AUDIO_ENCODER_IOCTL_GET_FRAME_COUNT:
16265 {
16266 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_COUNT, u8DeviceId);
16267 break;
16268 }
16269
16270 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_HIGH32BIT:
16271 {
16272 MS_U32 u32Data = 0;
16273
16274 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16275 u32Data = (u32Data & 0x80000000) >> 31;
16276 *((MS_U32 *)pData) = u32Data;
16277 break;
16278 }
16279
16280 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_LOW32BIT:
16281 {
16282 MS_U32 u32Data = 0;
16283
16284 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16285 u32Data = (u32Data << 1) & 0xFFFFFFFF;
16286 *((MS_U32 *)pData) = u32Data;
16287 break;
16288 }
16289
16290 default:
16291 {
16292 s32Ret = -A_EINVAL;
16293 break;
16294 }
16295 }
16296
16297 return s32Ret;
16298 #else
16299 return 0;
16300 #endif
16301 }
16302
HAL_AUDIO_MP3_ENCODER2_Read(void * pBuf,MS_U32 u32Size)16303 MS_U32 HAL_AUDIO_MP3_ENCODER2_Read(void *pBuf, MS_U32 u32Size)
16304 {
16305 #if AUDIO_MP3_ENCODER2_SUPPORT
16306 MS_S8 *pEncoderBuf = NULL;
16307 MS_S8 *pEncoderReadPtr = NULL;
16308 MS_S8 *pBufTmp = NULL;
16309 MS_U32 u32TargetBufferAddrPa = 0;
16310 MS_U32 u32BufferSize = 0;
16311 MS_U32 u32Mp3Level = 0;
16312 MS_U32 u32RequestSize = 0;
16313 MS_U32 u32RequestSizeTmp = 0;
16314 MS_U32 u32SizeToCopy = 0;
16315 MS_U32 u32Threshold = 0;
16316 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Read %u bytes from %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
16317
16318 if (pBuf == NULL)
16319 {
16320 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
16321 return 0;
16322 }
16323
16324 if (u32Size == 0)
16325 {
16326 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
16327 return 0;
16328 }
16329
16330 pBufTmp = (MS_S8 *)pBuf;
16331
16332 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + MP3_ENCODER2_BUF_ADDR;
16333 pEncoderBuf = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
16334 if (pEncoderBuf == NULL)
16335 {
16336 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pEncoderBuf should not be NULL!\n", __FUNCTION__);
16337 return 0;
16338 }
16339
16340 u32BufferSize = MP3_ENCODER2_BUF_SIZE;
16341 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE, &u32Mp3Level);
16342 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_THRESHOLD, &u32Threshold);
16343 if (u32Mp3Level >= (u32BufferSize - u32Threshold))
16344 {
16345 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer full!\n", __FUNCTION__);
16346
16347 u32Mp3Level = 0;
16348 HAL_AUDIO_MP3_ENCODER2_Stop();
16349 HAL_AUDIO_MP3_ENCODER2_Flush();
16350 HAL_AUDIO_MP3_ENCODER2_Start();
16351 }
16352 else if (u32Mp3Level == 0)
16353 {
16354 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16355 }
16356
16357 u32RequestSize = u32Size;
16358 u32RequestSizeTmp = u32RequestSize;
16359
16360 pEncoderReadPtr = pEncoderBuf + g_u32Mp3Encoder2RptrOffset;
16361
16362 //HALAUDIO_ERROR("[%u] %s: u32BufferSize %u, u32Threshold %u, u32Mp3Level %u, u32RequestSize %u\n", MsOS_GetSystemTime(), __FUNCTION__, u32BufferSize, u32Threshold, u32Mp3Level, u32RequestSize);
16363
16364 if (u32Mp3Level <= u32Threshold)
16365 {
16366 return 0;
16367 }
16368 u32Mp3Level -= u32Threshold;
16369
16370 /* copy data from PCM buffer */
16371 if (u32Mp3Level >= u32RequestSize)
16372 {
16373 do {
16374 u32SizeToCopy = (pEncoderBuf + u32BufferSize) - pEncoderReadPtr;
16375 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
16376
16377 /* read MIU */
16378 MsOS_ReadMemory();
16379
16380 #ifdef MSOS_TYPE_LINUX_KERNEL
16381 memcpy_toio((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16382 #else
16383 memcpy((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16384 #endif
16385 //HALAUDIO_ERROR("[%u] %s: g_u32Mp3Encoder2RptrOffset 0x%08X, SizeToCopy %u, ReadPtr 0x%08X, Buf 0x%08X, BufEnd 0x%08X\n", MsOS_GetSystemTime(), __FUNCTION__, g_u32Mp3Encoder2RptrOffset, u32SizeToCopy, pEncoderReadPtr, pEncoderBuf, (pEncoderBuf + u32BufferSize));
16386
16387 pBufTmp += u32SizeToCopy;
16388 pEncoderReadPtr += u32SizeToCopy;
16389 if (pEncoderReadPtr >= (pEncoderBuf + u32BufferSize))
16390 {
16391 if (pEncoderReadPtr > (pEncoderBuf + u32BufferSize))
16392 {
16393 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
16394 }
16395 pEncoderReadPtr = pEncoderBuf;
16396 }
16397
16398 u32RequestSizeTmp -= u32SizeToCopy;
16399 } while (u32RequestSizeTmp > 0);
16400
16401 /* flush MIU */
16402 MsOS_FlushMemory();
16403
16404 /* update read pointer to engine */
16405 g_u32Mp3Encoder2RptrOffset = pEncoderReadPtr - pEncoderBuf;
16406 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16407
16408 return u32Size;
16409 }
16410
16411 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16412
16413 return 0;
16414 #else
16415 return 0;
16416 #endif
16417 }
16418
HAL_AUDIO_MP3_ENCODER2_Flush(void)16419 MS_S32 HAL_AUDIO_MP3_ENCODER2_Flush(void)
16420 {
16421 #if AUDIO_MP3_ENCODER2_SUPPORT
16422 MS_U32 u32WptrOffset = 0;
16423 MS_S32 s32Ret = 0;
16424
16425 /* set read pointer as write pointer to flush data in buffer */
16426 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET, &u32WptrOffset);
16427 g_u32Mp3Encoder2RptrOffset = u32WptrOffset;
16428 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16429
16430 return s32Ret;
16431 #else
16432 return 0;
16433 #endif
16434 }
16435