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 #else
107 #include <stdio.h>
108 #include <string.h>
109 #include <pthread.h>
110 #endif
111
112 #include "MsCommon.h"
113 #include "MsIRQ.h"
114 #include "MsOS.h"
115 #include "MsTypes.h"
116 #include "drvSYS.h"
117 #include "halSYS.h"
118
119 // Internal Definition
120 #include "drvAUDIO.h"
121 #include "regCHIP.h"
122 #include "regAUDIO.h"
123 #include "halAUDIO.h"
124 #include "halMAD.h"
125 #include "halMAD2.h"
126 #include "halSIF.h"
127 #include "halSOUND.h"
128 #include "halAUR2.h"
129 #include "audio_comm2.h"
130
131 #include "halAUDSP.h"
132
133 #if defined(MSOS_TYPE_NUTTX)
134 extern int lib_lowprintf(const char *format, ...);
135 #define DBG_PREFIX lib_lowprintf
136 #else
137 #define DBG_PREFIX printf
138 #endif
139
140 #if (defined ANDROID)
141 #include <sys/mman.h>
142 #include <cutils/ashmem.h>
143 #include <cutils/log.h>
144
145 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
146 #define LOGI ALOGI
147 #endif
148
149 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
150 #define LOGE ALOGE
151 #endif
152
153 #define HALAUDIO_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
154 #define HALAUDIO_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
155 #else
156 #ifdef MBOOT_PLAY_MELODY
157 #define HALAUDIO_PRINT(fmt, args...)
158 #define HALAUDIO_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
159 #else
160 #define HALAUDIO_PRINT(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
161 #define HALAUDIO_ERROR(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
162 #endif
163 #endif
164
165
166 //-------------------------------------------------------------------------------------------------
167 // Driver Compiler Options
168 //-------------------------------------------------------------------------------------------------
169 #define DBG_AUDIO(args...) //DBG_PREFIX(args)
170 #define DBG_AUDIO_LOAD(args...) //DBG_PREFIX(args)
171 #define DBG_AUDIO_ERROR(args...) //DBG_PREFIX(args)
172
173 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
174 #define AUD_DBGMSG(args...) DBG_PREFIX(args)
175
176 #define HALAUDIO_CHECK_SHM_INIT \
177 do { \
178 if (g_AudioVars2 == NULL) \
179 { \
180 HALAUDIO_ERROR("%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
181 HALAUDIO_ERROR("%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
182 if (HAL_AUDIO_InitialVars() == FALSE) \
183 { \
184 MS_ASSERT(0); \
185 } \
186 } \
187 } while(0)
188
189 #ifndef MSOS_TYPE_NOS
190 void* MDrv_MPool_PA2KSEG1(void* pAddrPhys);
191 #endif
192
193 //-------------------------------------------------------------------------------------------------
194 // Local Defines
195 //-------------------------------------------------------------------------------------------------
196 #define AUDIO_HAL_ERR(x, args...) //{printf(x, ##args);}
197 #define HINIBBLE(u8Data) ((u8Data) >> 4)
198 #define LONIBBLE(u8Data) ((u8Data) << 4)
199 #if (AUDIO_R2_DMA_READER1_SUPPORT || AUDIO_R2_DMA_READER2_SUPPORT)
200 #define AUDIO_R2_DMA_RDER_CFG_REG(base, offset) ((MS_U32)(base + (offset * 2)))
201 #endif
202
203 #define HW_DMA_RDR1_BUF_UNIT 4096
204
205 #if AUDIO_HW_DMA_READER1_SUPPORT
206 #define HW_DMA_RDR1_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
207 #define HW_DMA_RDR1_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
208 #endif
209
210 #if AUDIO_HW_DMA_READER2_SUPPORT
211 #define HW_DMA_RDR2_BUF_ADDR (DSP2_HW_DMA_READER2_DRAM_BASE * BYTES_IN_MIU_LINE)
212 #define HW_DMA_RDR2_BUF_SIZE ((DSP2_HW_DMA_READER2_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
213 #endif
214
215 #if AUDIO_SW_DMA_READER1_SUPPORT
216 #define SW_DMA_RDR1_BUF_ADDR (DSP2_SW_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
217 #define SW_DMA_RDR1_BUF_SIZE ((DSP2_SW_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
218 #endif
219
220 #if AUDIO_R2_DMA_READER1_SUPPORT
221 #define R2_DMA_RDR1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA1_READER_DRAM_BASE)
222 #define R2_DMA_RDR1_BUF_SIZE MCU_R2_DMA1_READER_DRAM_SIZE
223 #endif
224
225 #if AUDIO_R2_DMA_READER2_SUPPORT
226 #define R2_DMA_RDR2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA2_READER_DRAM_BASE)
227 #define R2_DMA_RDR2_BUF_SIZE MCU_R2_DMA2_READER_DRAM_SIZE
228 #endif
229
230 #if AUDIO_PCM_CAPTURE1_SUPPORT
231 #define PCM_CAPTURE1_BUF_UNIT 128
232 #define PCM_CAPTURE1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
233 #define PCM_CAPTURE1_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
234 #endif
235
236 #if AUDIO_PCM_CAPTURE2_SUPPORT
237 #define PCM_CAPTURE2_BUF_UNIT 128
238 #define PCM_CAPTURE2_BUF_ADDR (DSP2_PCM_CAPTURE2_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
239 #define PCM_CAPTURE2_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
240 #endif
241
242 #if AUDIO_HW_DMA_WRITER1_SUPPORT
243 #define HW_DMA_WTR1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
244 #define HW_DMA_WTR1_BUF_SIZE ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE) * BYTES_IN_MIU_LINE)
245 #endif
246
247 #ifndef UNUSED
248 #define UNUSED(x) ((x)=(x))
249 #endif
250
251 #define StereoAACOutputPCM 0
252 #define HW_AutoDepop 1
253
254 //-------------------------------------------------------------------------------------------------
255 // Local Structures
256 //-------------------------------------------------------------------------------------------------
257 static MS_U8 SIF_MailBoxArray[12];
258
259 //-------------------------------------------------------------------------------------------------
260 // Global Variables
261 //-------------------------------------------------------------------------------------------------
262 AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
263 AUDIO_INPUT_TYPE g_audioSrcType = AUDIO_DSP1_DVB_INPUT;
264 AUDIO_INPUT_TYPE g_audioSubSrcType = AUDIO_DSP1_DVB_INPUT;
265 MS_U16 g_BalanceMask = 0x0000;
266 MS_BOOL g_bAudio_loadcode_from_dram = 0, g_bIsDTV;
267 MS_VIRT _gMIO_MapBase;
268 MS_S32 _s32AUDIOMutex = -1;
269 MS_S32 _s32AUDIOMutexReboot = -1;
270 MS_S32 _s32MutexLoadCode = -1;
271 MS_S32 _s32AUDIOMutexIDMA = -1;
272 MS_U8 CheckPlayDoneCnt = 0;
273 extern MS_BOOL g_bDSPLoadCode;
274 MS_U32 g_u32bDTSCD = 0x00;
275 MS_BOOL bReBoot_All_Aud_Proc = FALSE;
276
277 extern AUDIO_SHARED_VARS2 * g_AudioVars2;
278
279 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
280 #else
281 AUDIO_SHARED_VARS2 g_audioShared;
282 #endif
283
284 #ifndef MSOS_TYPE_NUTTX
285 static MS_BOOL g_bAudioTeeInfoShmInitFlag = FALSE;
286 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
287 #else
288 AUDIO_TEE_INFO_SHARE_MEM gAudioTeeInfoShm;
289 #endif
290 AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm = NULL;
291
292 MS_BOOL g_bAudioTeeEnabled = FALSE, g_bAudioTeeMbxInitialized = FALSE;
293 MS_BOOL g_bDecDspSecureTeeAccessed = FALSE, g_bSndDspSecureTeeAccessed = FALSE;
294 #endif
295
296 //-------------------------------------------------------------------------------------------------
297 // Local Variables
298 //-------------------------------------------------------------------------------------------------
299 static MS_U32 curr_OS_Time=0;
300 static MS_S64 curr_PTS = 0;
301 static MS_BOOL g_bInitShmFlag = FALSE;
302 static MS_BOOL g_bEncodeDoneFlag = 0;
303 static MS_U8 * dma_writePtr;
304 static MS_U8 * dma_bufStartAddress;
305 static MS_U8 * dma_bufEndAddress;
306 static MS_U8 Dvb2DecCmd_tmp;
307 static AUDIO_DEC_ID DTVDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
308 static AUDIO_DEC_ID HDMIDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_INVALID , AU_DEC_INVALID};
309 static AUDIO_DEC_ID MMDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_INVALID , AU_DEC_INVALID};
310
311 #ifdef MSOS_TYPE_NUTTX
312 static MS_S32 _s32MadEventId = -1;
313 static MS_S32 _s32MadTaskId = -1;
314 static MBX_Msg TeeToReeMbxAckMsg;
315 static MBX_Msg msg;
316 static void _MAD_Proc(void);
317 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue);
318 #endif
319
320 MS_U32 g_pcm_capture_base_addr = 0;
321 MS_U32 g_pcm_capture2_base_addr = 0;
322
323 MS_U8 g_DSPMadMIUBank[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
324 MS_U32 g_DSPBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
325 MS_U32 g_DSPMadBaseBufferAdr[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
326 MS_U32 g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
327 extern MS_U32 (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
328
329 extern MS_U32 g_AudioDumpInfoCtrl;
330 extern MS_BOOL bIsNonPCMInDec2;
331 extern MS_U32 EncFrameIdx;
332 extern MS_U32 EncBuf_W_idx;
333 extern MS_U8 EncBuf_Count;
334 extern AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
335
336 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
337 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
338 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
339 extern MS_U32 (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
340
341 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
342
343
344 const MS_U32 u32PathArray[8]={0x2C64, 0x2C66, 0x2C68, 0x2C6A, 0x2C65, 0x2C67, 0x2C69, 0x2C6B};
345
346 //Refine power on sequence for earphone & DAC pop noise issue
347 const AUDIO_REG_TYPE AudioPreInitTbl_Clock_0[] =
348 {
349
350 //----------------pre-AUPLL-------------------------//Item 23
351 {0x112c9e, 0xff, 0x20}, //[15:0] 2nd order synthesizer n.f[23:8]
352 {0x112c9f, 0xff, 0x1c},
353 {0x112c9c, 0xff, 0x00}, //[7:0] 2nd order synthesizer n.f[7:0]
354 {0x112c9d, 0xff, 0xc0}, //[15] 2nd order synthesizer enable, [14] load
355 {0x112ca0, 0xff, 0x20}, //[15:0] codec synthesizer n.f << 112ca2[4] do not select codec synthesizer 1024FS clk
356 {0x112ca1, 0xff, 0x1c},
357 {0x112c9c, 0xff, 0x00},
358 {0x112c9d, 0xff, 0x80}, //[14] 2nd order synthesizer load
359 {0x112ca2, 0x08, 0x08}, //[3] Enable reference clock
360 {0x112ca2, 0x10, 0x10}, //[4] Select 1st-order or 2nd-order synthesizer
361 //----------------AUPLL control-------------------------//Item 23
362 {0x112c76, 0xff, 0x00},
363 {0x112c77, 0xff, 0x03},
364
365 //----------------AUR2PLL------------------------//Item 22
366 {0x160342, 0xff, 0x01}, //
367 {0x160343, 0xff, 0x00}, //[8] Set AUR2PLL power down = 0
368
369 //---------------- Enable CLK----------------------------//Item 32
370 {0x112ca4, 0xff, 0xff}, //[10:0] CLKGEN's clock enable
371 {0x112ca5, 0xff, 0x1f},
372 {0x112cb2, 0x90, 0x90}, //[7] CLK R2 EN[3], [4] CLK PARSER EN
373 {0x112cb3, 0x60, 0x60}, //[14:13] CLK R2 EN[2:1]
374 {0x112ccb, 0x3c, 0x3c}, //[13:10] CLK DSP EN[4:1]
375
376 //----------------- DFS ---------------------------//Item 36
377 {0x163c61, 0x03, 0x00}, //[9:8] CLK DSP DFS SEL[1:0] = AUPLL
378 {0x163c61, 0x10, 0x00}, //[12] CLK DSP DFS SEL[2] = 0
379 {0x163c61, 0x08, 0x08}, //[11] CLK DSP DFS EN
380 {0x163c60, 0x1f, 0x1f}, //[4:0] DSP DFS DIV
381 {0x163c60, 0x40, 0x40}, //[6] DSP DFS EN
382 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
383 {0x163c60, 0x80, 0x80}, //[7] DSP DFS UPDATE
384 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
385 {0x163c63, 0x03, 0x00}, //[9:8] CLK R2 DFS SEL[1:0] = AUR2PLL
386 {0x163c63, 0x10, 0x00}, //[12] CLK R2 DFS SEL[2] = 0
387 {0x163c63, 0x08, 0x08}, //[11] CLK R2 DFS EN
388 {0x163c62, 0x1f, 0x1f}, //[4:0] R2 DFS DIV
389 {0x163c62, 0x40, 0x40}, //[6] R2 DFS EN
390 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
391 {0x163c62, 0x80, 0x80}, //[7] R2 DFS UPDATE
392 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
393
394
395 {0xffffff, 0x00, 0x00}, // end of table
396 };
397
398
399 const AUDIO_REG_TYPE AudioPreInitTbl_Clock_1[] =
400 {
401 //----------------Audio Reset---------------------------//Item 24
402 {0x112c00, 0xff, 0x0d},
403 {0x112c01, 0xff, 0x7f},
404 {0x112c00, 0xff, 0x0f}, //[1] CLKGEN_RESET
405 {0x112c01, 0xff, 0x7f},
406 {0x112c00, 0xff, 0x0d},
407 {0x112c01, 0xff, 0x7f},
408 {0x112c00, 0xff, 0x00},
409 {0x112c01, 0xff, 0x00},
410
411 //-----------------Synthesizer--------------------------//Item 29
412 {0x112bcf, 0x01, 0x01}, // DVB1
413 {0x112bce, 0x01, 0x01},
414 {0x112ba8, 0xff, 0x94},
415 {0x112ba9, 0xff, 0x11},
416 {0x112baa, 0xff, 0x00},
417 {0x112bab, 0xff, 0x00},
418 {0x112c60, 0x80, 0x80},
419 {0x112bce, 0x01, 0x00},
420
421 {0x112bcf, 0x02, 0x02}, // DVB2
422 {0x112bce, 0x02, 0x02},
423 {0x112bac, 0xff, 0x94},
424 {0x112bad, 0xff, 0x11},
425 {0x112bae, 0xff, 0x00},
426 {0x112baf, 0xff, 0x00},
427 {0x112c62, 0x80, 0x80},
428 {0x112bce, 0x02, 0x00},
429
430 {0x112bcf, 0x04, 0x04}, // DVB3
431 {0x112bce, 0x04, 0x04},
432 {0x112bb0, 0xff, 0x94},
433 {0x112bb1, 0xff, 0x11},
434 {0x112bb2, 0xff, 0x00},
435 {0x112bb3, 0xff, 0x00},
436 {0x112c61, 0x80, 0x80},
437 {0x112bce, 0x04, 0x00},
438
439 {0x112bcf, 0x08, 0x08}, // DVB4
440 {0x112bce, 0x08, 0x08},
441 {0x112bb4, 0xff, 0x94},
442 {0x112bb5, 0xff, 0x11},
443 {0x112bb6, 0xff, 0x00},
444 {0x112bb7, 0xff, 0x00},
445 {0x112c63, 0x80, 0x80},
446 {0x112bce, 0x08, 0x00},
447
448 {0x112bcf, 0x10, 0x10}, // NonPCM
449 {0x112bce, 0x20, 0x20},
450 {0x112bb8, 0xff, 0x94},
451 {0x112bb9, 0xff, 0x11},
452 {0x112bba, 0xff, 0x00},
453 {0x112bbb, 0xff, 0x00},
454 {0x112c8b, 0x40, 0x40},
455 {0x112bce, 0x20, 0x00},
456
457 {0x112bcf, 0x20, 0x20}, // NonPCM2
458 {0x112bce, 0x10, 0x10},
459 {0x112bd0, 0xff, 0x94},
460 {0x112bd1, 0xff, 0x11},
461 {0x112bd2, 0xff, 0x00},
462 {0x112bd3, 0xff, 0x00},
463 {0x112c5f, 0x40, 0x40},
464 {0x112bce, 0x10, 0x00},
465
466 {0x112bcf, 0x40, 0x40}, // NonPCM3
467 {0x112bcf, 0x80, 0x80},
468 {0x112bd6, 0xff, 0x94},
469 {0x112bd7, 0xff, 0x11},
470 {0x112bd8, 0xff, 0x00},
471 {0x112bd9, 0xff, 0x00},
472 {0x112c48, 0x80, 0x80},
473 {0x112bcf, 0x80, 0x00},
474
475 {0x112c25, 0x20, 0x20}, // DVB5
476 {0x112c25, 0x10, 0x10},
477 {0x112c26, 0xff, 0x94},
478 {0x112c27, 0xff, 0x11},
479 {0x112c28, 0xff, 0x00},
480 {0x112c29, 0xff, 0x00},
481 {0x112c25, 0x80, 0x80},
482 {0x112c25, 0x10, 0x00},
483
484 {0x112c25, 0x02, 0x02}, // DVB6
485 {0x112c25, 0x01, 0x01},
486 {0x112c2a, 0xff, 0x94},
487 {0x112c2b, 0xff, 0x11},
488 {0x112c2c, 0xff, 0x00},
489 {0x112c2d, 0xff, 0x00},
490 {0x112c25, 0x08, 0x08},
491 {0x112c25, 0x01, 0x00},
492
493 {0x112bcf, 0x01, 0x00}, // DVB1 is controlled by DSP/R2
494 {0x112bcf, 0x02, 0x00}, // DVB2 is controlled by DSP/R2
495 {0x112bcf, 0x04, 0x00}, // DVB3 is controlled by DSP/R2
496 {0x112bcf, 0x08, 0x00}, // DVB4 is controlled by DSP/R2
497 {0x112c25, 0x20, 0x00}, // DVB5 is controlled by DSP/R2
498 {0x112c25, 0x02, 0x00}, // DVB6 is controlled by DSP/R2
499
500 {0x112bcf, 0x10, 0x00}, // NonPCM1 is controlled by DSP/R2
501 {0x112bcf, 0x20, 0x00}, // NonPCM2 is controlled by DSP/R2
502 {0x112bcf, 0x40, 0x00}, // NonPCM3 is controlled by DSP/R2
503
504 //---------------- AudioBand ROM----------------------------//Item 35
505 //additional 8 SRC needed
506
507 //-----------------AudioBand----------------------------//Item 21
508 {0x112b58, 0xff, 0xff}, //[15:0] DWA fix value
509 {0x112b59, 0xff, 0x01}, //[15:0] DWA fix value
510 {0x112b55, 0xf0, 0xf0}, //[15:12] DWA fix enable
511 {0x112b46, 0xff, 0x00}, //[15:0] Enable Group C
512 {0x112b47, 0xff, 0xff},
513 {0x112b56, 0xff, 0x30}, //[15:0] Enable ADC1/2
514 {0x112b57, 0xff, 0x00},
515 {0x112c6e, 0xff, 0x88}, //[7:0] Enable Grp A/B
516 {0x112b50, 0xff, 0x80}, //[15:0] DC offset value
517 {0x112b51, 0xff, 0x00},
518 {0x112b10, 0xff, 0x80}, //[15:0] DC offset value for earphone
519 {0x112b60, 0xff, 0xc0},
520 {0x112b61, 0xff, 0x38},
521 {0x112b62, 0xff, 0x38},
522 {0x112b63, 0xff, 0x38},
523 {0x112b40, 0xff, 0x4e}, //[15:0] Init CODEC SRC
524 {0x112b41, 0xff, 0x00},
525 {0x112b54, 0xff, 0x00}, //[15:0] DITHER select 0.5LSB
526 {0x112b55, 0xff, 0x01},
527 {0x112b52, 0xff, 0x0f}, //[15:0] DC offset ENABLE=0, Dither ENABLE=0
528 {0x112b53, 0xff, 0xf0},
529 {0x112b40, 0xff, 0x0c}, //[15:0] Init CODEC SRC
530 {0x112b41, 0xff, 0x00},
531 {0x112b54, 0x01, 0x01}, //[0] SDM EN
532
533 //-----------------De-POP_1-----------------------------//Item 25
534 #if (HW_AutoDepop == 1) // auto depop
535 {0x103346, 0x0f, 0x00}, // [0] Auto-depop clock gate
536 {0x112e70, 0xff, 0x15}, //wriu -w 0x112e70 0xDB15 //Value 0
537 {0x112e71, 0xff, 0xdb},
538 {0x112e72, 0xff, 0x01}, //wriu -w 0x112e72 0x0001 //
539 {0x112e73, 0xff, 0x00},
540 {0x112ec0, 0xff, 0x15}, //wriu -w 0x112ec0 0xC015 //1
541 {0x112ec1, 0xff, 0xc0},
542 {0x112ec2, 0xff, 0x00}, //wriu -w 0x112ec2 0x0000 //
543 {0x112ec3, 0xff, 0x00},
544 {0x112ec4, 0xff, 0x51}, //wriu -w 0x112ec4 0xA051 //2
545 {0x112ec5, 0xff, 0xa0},
546 {0x112ec6, 0xff, 0x00}, //wriu -w 0x112ec6 0x0000 //
547 {0x112ec7, 0xff, 0x00},
548 {0x112ec8, 0xff, 0x59}, //wriu -w 0x112ec8 0xA059 //3
549 {0x112ec9, 0xff, 0xa0},
550 {0x112eca, 0xff, 0x00}, //wriu -w 0x112eca 0x0000 //
551 {0x112ecb, 0xff, 0x00},
552 {0x112ecc, 0xff, 0x5b}, //wriu -w 0x112ecc 0xA05B //4
553 {0x112ecd, 0xff, 0xa0},
554 {0x112ece, 0xff, 0x00}, //wriu -w 0x112ece 0x0000 //
555 {0x112ecf, 0xff, 0x00},
556 {0x112ed0, 0xff, 0xcb}, //wriu -w 0x112ed0 0xA0CB //5
557 {0x112ed1, 0xff, 0xa0},
558 {0x112ed2, 0xff, 0x00}, //wriu -w 0x112ed2 0x0000 //
559 {0x112ed3, 0xff, 0x00},
560 {0x112ed4, 0xff, 0xcb}, //wriu -w 0x112ed4 0xA0CB //6
561 {0x112ed5, 0xff, 0xa0},
562 {0x112ed6, 0xff, 0x00}, //wriu -w 0x112ed6 0x0000 //
563 {0x112ed7, 0xff, 0x00},
564
565 {0x112e68, 0xff, 0x00}, //wriu -w 0x112e68 0x0300 //Time 0
566 {0x112e69, 0xff, 0x03},
567 #ifdef CONFIG_MBOOT // define for power on music unstable
568 {0x112e6a, 0xff, 0x2e}, //wriu -w 0x112e6a 0x122e //1
569 #else
570 {0x112e6a, 0xff, 0x69}, //wriu -w 0x112e6a 0x1269 //1
571 #endif
572 {0x112e6b, 0xff, 0x12},
573 {0x112e6c, 0xff, 0x2b}, //wriu -w 0x112e6c 0x452B //3
574 {0x112e6d, 0xff, 0x45},
575 {0x112e6e, 0xff, 0x00}, //wriu -w 0x112e6e 0x0000 //5
576 {0x112e6f, 0xff, 0x00},
577
578 {0x112ed8, 0xff, 0x09}, //wriu -w 0x112ed8 0x9 //AutoBootStart
579 {0x112ed9, 0xff, 0x00},
580
581 {0x112cda, 0xff, 0x2b}, //wriu -w 0x112cda 0x32B //Final Step
582 {0x112cdb, 0xff, 0x03},
583 {0x112cdc, 0xff, 0x00}, //wriu -w 0x112cdc 0x0 //
584 {0x112cdd, 0xff, 0x00},
585 {0x112cde, 0xff, 0x00}, //wriu -w 0x112cde 0x7800 //
586 {0x112cdf, 0xff, 0x78},
587 {0x112ce0, 0xff, 0x00}, //wriu -w 0x112ce0 0x0 //
588 {0x112ce1, 0xff, 0x00},
589 {0x112ce2, 0xff, 0x00}, //wriu -w 0x112ce2 0x1000 //
590 {0x112ce3, 0xff, 0x10},
591 {0x112ce6, 0xff, 0x00}, //wriu -w 0x112ce6 0x0 //
592 {0x112ce7, 0xff, 0x00},
593 {0x112ce8, 0xff, 0x00}, //wriu -w 0x112ce8 0x0 //
594 {0x112ce9, 0xff, 0x00},
595 {0x112cea, 0xff, 0x00}, //wriu -w 0x112cea 0x0 //
596 {0x112ceb, 0xff, 0x00},
597 {0x112cec, 0xff, 0x00}, //wriu -w 0x112cec 0x1800 //
598 {0x112ced, 0xff, 0x18},
599 {0x112cee, 0xff, 0x03}, //wriu -w 0x112cee 0x303 //
600 {0x112cef, 0xff, 0x03},
601 {0x112ee0, 0xff, 0x0c}, //wriu -w 0x112ee0 0xC //
602 {0x112ee1, 0xff, 0x00},
603 #else
604 {0x112ee0, 0x0c, 0x0c}, //EN_CHOP_DAC
605 {0x112cdc, 0xff, 0xf0},
606 {0x112cdd, 0xff, 0x3f},
607 {0x112cde, 0xff, 0x00},
608 {0x112cdf, 0xff, 0x00},
609 {0x112ce6, 0xff, 0x01},
610 {0x112ce7, 0xff, 0x00},
611 {0x112ce8, 0xff, 0x00},
612 {0x112ce9, 0xff, 0x80},
613 {0x112ce2, 0xff, 0x01}, //[7:4]SEL_CH_INMUX0,[3:0]SEL_CH_INMUX1
614 {0x112ce3, 0xff, 0x00},
615 {0x112ce0, 0xff, 0x30},
616 {0x112ce1, 0xff, 0x10},
617 {0x112cea, 0xff, 0x08},
618 {0x112ceb, 0xff, 0x00},
619 {0x112cee, 0xff, 0x00},
620 {0x112cef, 0xff, 0x00},
621 {0x112cec, 0xff, 0x00}, //[7]PD_LDO_ADC,[5]QS_LDO_ADC,[4]PD_LDO_DAC,[3]QS_LDO_DAC
622 {0x112ced, 0xff, 0x00},
623
624 {0x112cde, 0xff, 0x00},
625 {0x112cdf, 0xff, 0x78},
626 {0x112cea, 0xff, 0x08}, //[2]EN_VMID2GND_EAR
627 {0x112ceb, 0xff, 0x00},
628 {0x112cee, 0xff, 0x81}, //[7]EN_MUTE_EAR
629 {0x112cef, 0xff, 0x10},
630 {0x112cec, 0xff, 0x28},
631 {0x112ced, 0xff, 0x00},
632
633 {0xffffff, 0x01, 0x01}, // wait 1 //delay 1ms
634 {0x112cdc, 0xff, 0x00},
635 {0x112cdd, 0xff, 0x00},
636 {0x112ce6, 0xff, 0x00},
637 {0x112ce7, 0xff, 0x00},
638 {0x112ce8, 0xff, 0x00},
639 {0x112ce9, 0xff, 0x00},
640 {0x112cea, 0xff, 0x00}, //[3]PD_OPLP_EAR,[2]EN_VMID2GND_EAR
641 {0x112ceb, 0xff, 0x00},
642 #endif //End of #if (HW_AutoDepop == 1) // auto depop
643
644 {0xffffff, 0x00, 0x00}, //end of table
645 };
646
647 const AUDIO_REG_TYPE AudioInitTbl[]=
648 {
649 #if (HW_AutoDepop == 1)
650 // Mantis ID:1199683
651 // This delay is for ac on video green noise,add delay will ok. But not known why cause timer issue.
652 {0xffffff, 0x01, 0xff}, // delay 256ms
653 #else // remove for auto depop
654 //wait 1536 //delay 1536ms
655 //{0xffffff, 0x01, 0xff},
656 //{0xffffff, 0x01, 0xff},
657 //{0xffffff, 0x01, 0xff},
658 //{0xffffff, 0x01, 0xff},
659 {0xffffff, 0x01, 0xff},
660 {0xffffff, 0x01, 0xff},
661 //-----------------De-POP_2-----------------------------//Item 26
662 {0x112ce0, 0xff, 0x00},
663 {0x112ce1, 0xff, 0x00},
664 {0x112ce2, 0xff, 0x01}, //[7:4]SEL_CH_INMUX0,[3:0]SEL_CH_INMUX1
665 {0x112ce3, 0xff, 0x10},
666 {0x112ce8, 0xff, 0x00},
667 {0x112ce9, 0xff, 0x00},
668 {0x112cec, 0xff, 0x28},
669 {0x112ced, 0xff, 0x08},
670 {0x112cee, 0xff, 0x01}, //[7]EN_MUTE_EAR
671 {0x112cef, 0xff, 0x10},
672
673 {0xffffff, 0x01, 0x01}, //wait 1 // delay 50ms -> 1ms
674 {0x112cee, 0xff, 0x01},
675 {0x112cef, 0xff, 0x13}, //[9]EN_LTX_EAR,[8]EN_RTX_EAR
676
677 {0xffffff, 0x01, 0x32}, //wait 50 // delay 300ms -> 50ms
678 {0x112cee, 0xff, 0x03},
679 {0x112cef, 0xff, 0x13},
680 #endif //End of #if (HW_AutoDepop == 1)
681
682 //-----------------Input: HDMI (only Vivaldi side)------//Item 1
683 {0x112c44, 0xff, 0x00}, // [4:0] HDMI Matrix CFG
684 {0x112c45, 0xff, 0x00}, // [12:8]HDMI Matrix WD
685 {0x112c44, 0xff, 0x01}, // [4:0] HDMI Matrix CFG
686 {0x112c45, 0xff, 0x01}, // [12:8]HDMI Matrix WD
687 {0x112c44, 0xff, 0x02}, // [4:0] HDMI Matrix CFG
688 {0x112c45, 0xff, 0x02}, // [12:8]HDMI Matrix WD
689 {0x112c44, 0xff, 0x03}, // [4:0] HDMI Matrix CFG
690 {0x112c45, 0xff, 0x03}, // [12:8]HDMI Matrix WD
691 {0x112c44, 0xff, 0x04}, // [4:0] HDMI Matrix CFG
692 {0x112c45, 0xff, 0x04}, // [12:8]HDMI Matrix WD
693 {0x112c44, 0xff, 0x05}, // [4:0] HDMI Matrix CFG
694 {0x112c45, 0xff, 0x05}, // [12:8]HDMI Matrix WD
695 {0x112c44, 0xff, 0x06}, // [4:0] HDMI Matrix CFG
696 {0x112c45, 0xff, 0x06}, // [12:8]HDMI Matrix WD
697 {0x112c44, 0xff, 0x07}, // [4:0] HDMI Matrix CFG
698 {0x112c45, 0xff, 0x07}, // [12:8]HDMI Matrix WD
699 {0x112c44, 0xff, 0x08}, // [4:0] HDMI Matrix CFG
700 {0x112c45, 0xff, 0x08}, // [12:8]HDMI Matrix WD
701 {0x112c44, 0xff, 0x09}, // [4:0] HDMI Matrix CFG
702 {0x112c45, 0xff, 0x09}, // [12:8]HDMI Matrix WD
703 {0x112c44, 0xff, 0x0a}, // [4:0] HDMI Matrix CFG
704 {0x112c45, 0xff, 0x0a}, // [12:8]HDMI Matrix WD
705 {0x112c44, 0xff, 0x0b}, // [4:0] HDMI Matrix CFG
706 {0x112c45, 0xff, 0x0b}, // [12:8]HDMI Matrix WD
707 {0x112c44, 0xff, 0x0c}, // [4:0] HDMI Matrix CFG
708 {0x112c45, 0xff, 0x0c}, // [12:8]HDMI Matrix WD
709 {0x112c44, 0xff, 0x0d}, // [4:0] HDMI Matrix CFG
710 {0x112c45, 0xff, 0x0d}, // [12:8]HDMI Matrix WD
711 {0x112c44, 0xff, 0x0e}, // [4:0] HDMI Matrix CFG
712 {0x112c45, 0xff, 0x0e}, // [12:8]HDMI Matrix WD
713 {0x112c44, 0xff, 0x0f}, // [4:0] HDMI Matrix CFG
714 {0x112c45, 0xff, 0x0f}, // [12:8]HDMI Matrix WD
715 {0x112c44, 0xff, 0x10}, // [4:0] HDMI Matrix CFG
716 {0x112c45, 0xff, 0x10}, // [12:8]HDMI Matrix WD
717 {0x112c44, 0xff, 0x11}, // [4:0] HDMI Matrix CFG
718 {0x112c45, 0xff, 0x11}, // [12:8]HDMI Matrix WD
719 {0x112c44, 0xff, 0x12}, // [4:0] HDMI Matrix CFG
720 {0x112c45, 0xff, 0x12}, // [12:8]HDMI Matrix WD
721 {0x112c44, 0xff, 0x13}, // [4:0] HDMI Matrix CFG
722 {0x112c45, 0xff, 0x13}, // [12:8]HDMI Matrix WD
723 {0x112c44, 0xff, 0x14}, // [4:0] HDMI Matrix CFG
724 {0x112c45, 0xff, 0x14}, // [12:8]HDMI Matrix WD
725 {0x112c44, 0xff, 0x15}, // [4:0] HDMI Matrix CFG
726 {0x112c45, 0xff, 0x15}, // [12:8]HDMI Matrix WD
727 {0x112c44, 0xff, 0x16}, // [4:0] HDMI Matrix CFG
728 {0x112c45, 0xff, 0x16}, // [12:8]HDMI Matrix WD
729 {0x112c44, 0xff, 0x17}, // [4:0] HDMI Matrix CFG
730 {0x112c45, 0xff, 0x17}, // [12:8]HDMI Matrix WD
731 {0x112c44, 0xff, 0x18}, // [4:0] HDMI Matrix CFG
732 {0x112c45, 0xff, 0x18}, // [12:8]HDMI Matrix WD
733 {0x112c44, 0xff, 0x19}, // [4:0] HDMI Matrix CFG
734 {0x112c45, 0xff, 0x19}, // [12:8]HDMI Matrix WD
735 {0x112c44, 0xff, 0x1a}, // [4:0] HDMI Matrix CFG
736 {0x112c45, 0xff, 0x1a}, // [12:8]HDMI Matrix WD
737 {0x112c44, 0xff, 0x1b}, // [4:0] HDMI Matrix CFG
738 {0x112c45, 0xff, 0x1b}, // [12:8]HDMI Matrix WD
739 {0x112c44, 0xff, 0x1c}, // [4:0] HDMI Matrix CFG
740 {0x112c45, 0xff, 0x1c}, // [12:8]HDMI Matrix WD
741 {0x112c44, 0xff, 0x1d}, // [4:0] HDMI Matrix CFG
742 {0x112c45, 0xff, 0x1d}, // [12:8]HDMI Matrix WD
743 {0x112c44, 0xff, 0x1e}, // [4:0] HDMI Matrix CFG
744 {0x112c45, 0xff, 0x1e}, // [12:8]HDMI Matrix WD
745 {0x112c44, 0xff, 0x1f}, // [4:0] HDMI Matrix CFG
746 {0x112c45, 0xff, 0x1f}, // [12:8]HDMI Matrix WD
747 {0x11176a, 0xff, 0x7f}, // [6:0] HDMI RX LAUNCH CFG
748 {0x111718, 0x33, 0x20}, // [2:0]HDMI status channel SEL, [5:4]HDMI status SEL
749 {0x111719, 0xff, 0x0d}, // [8]HDMI left justified, [9]MSB first, [15:10]HDMI status block start SEL
750 {0x112c47, 0x83, 0x01}, // [8]DSD MODE SW SEL, [9]DSD MODE SW, [15]MCH EN
751 {0x112c48, 0x10, 0x10}, // [4] npcm byte mode
752 {0x112c48, 0x08, 0x08}, // [3] npcm decoder PA/PB order
753 {0x112c48, 0x04, 0x00}, // [2] npcm decoder fast lock
754 {0x112c48, 0x03, 0x00}, // [1:0] npcm decoder time out SEL
755
756 //-----------------Input: I2S (default slave)---------------------------//Item 2
757 {0x112c02, 0xff, 0x1f}, // [3:0] I2S/SIF/SPDIF clk EN, [4] I2S left-justified
758 {0x112c03, 0xff, 0xc0}, // [14]AUTO_CLEAR_PC_PD_BAR, [15]SPDIF_IN_BLOCK_NO_CHECK
759 {0x112cae, 0xff, 0x0e}, // [3:1] non-pcm synthesizer source SEL 432MHz
760 {0x112caf, 0xff, 0x40}, // [15:13]i2s fs synthesizer SEL source clock 432MHz
761
762 //-----------------Input: SPDIF-------------------------//Item 3
763 {0x112c0a, 0xff, 0x70},
764 {0x112c0b, 0xff, 0x13},
765
766 //-----------------Input: ADC---------------------------//Item 4
767 {0x112cda, 0xff, 0x2b},
768 {0x112cdb, 0xff, 0x03},
769 {0x112cda, 0xff, 0x28}, // [1:0]PD_ADC
770 {0x112cdb, 0xff, 0x03},
771 {0x112cf2, 0xff, 0x21}, // ADC set invert
772 {0x112cf3, 0xff, 0x0f},
773
774 //-----------------Decode Path--------------------------//Item 28
775 {0x112c60, 0xff, 0x80}, // Decoder 1 source from DVB1
776 {0x112c61, 0xff, 0x80}, // Decoder 3 source from DVB3
777 {0x112c62, 0xff, 0x80}, // Decoder 2 source from DVB2
778 {0x112c63, 0xff, 0x87}, // Decoder 4 source from SIF
779
780 //-----------------SIF init table-----------------------//Item 27/31
781 //call Jeff-CY.Lee(#7019) for VIF_SIF_ini_table.xls
782
783 //-----------------Input: Channel Source----------------//Item 6
784 {0x112c64, 0xff, 0x80}, // CH1: Source0 , CH5: ADC0
785 {0x112c65, 0xff, 0x80}, // Set CH5 default source from decoder
786 {0x112c66, 0xff, 0x80}, // CH2: Source0 , CH6: Source1
787 {0x112c67, 0xff, 0x81},
788 {0x112c68, 0xff, 0x80}, // CH3: Source0 , CH7: Source3
789 {0x112c69, 0xff, 0x83},
790 {0x112c6a, 0xff, 0x80}, // CH4: Source0 , CH8: Source7
791 {0x112c6b, 0xff, 0x87},
792
793 //-----------------Output: I2S (BCK 64fs, msater)--------------------------//Item 10
794 {0x112c90, 0x40, 0x00},
795 {0x112c90, 0x1e, 0x00},
796 {0x112c8d, 0x02, 0x00},
797 {0x112c8d, 0x01, 0x00},
798 {0x112c8c, 0x70, 0x20},
799 {0x112c8c, 0x08, 0x00},
800 {0x112c8c, 0x07, 0x02},
801 {0x112c8d, 0x80, 0x80},
802 {0x112c8d, 0x40, 0x40},
803 {0x112c8d, 0x08, 0x08},
804 {0xffffff, 0x01, 0x01}, // delay 1ms
805 {0x112c8d, 0x40, 0x00},
806 {0x112c8d, 0x08, 0x00},
807
808 //-----------------Output: SPDIF TX1--------------------//Item 11
809 {0x112c90, 0x01, 0x00},
810 {0x112c8b, 0x80, 0x80},
811 {0x112c8b, 0x20, 0x00},
812 {0x112c8b, 0x10, 0x00},
813 {0x112c8b, 0x08, 0x00},
814 {0x112c8b, 0x04, 0x00},
815 {0x112c8b, 0x02, 0x00},
816 {0x112c8b, 0x01, 0x00},
817 {0x112c8a, 0x10, 0x10}, //[4]spdif status from RIU
818 {0x112c8a, 0x08, 0x00},
819 {0x112c8a, 0x04, 0x00},
820 {0x112c8a, 0x03, 0x00},
821 {0x112c8a, 0x80, 0x80},
822 {0x112c8a, 0x40, 0x40},
823 {0x112c8a, 0x20, 0x20},
824 {0xffffff, 0x01, 0x01}, // delay 1ms
825 {0x112c8a, 0x40, 0x00},
826 {0x112c8a, 0x20, 0x00},
827
828 //-----------------Output: DAC--------------------------//Item 12
829 #if (HW_AutoDepop == 0) // remove for auto depop
830 {0xffffff, 0x01, 0xfa},
831 {0xffffff, 0x01, 0x64}, //wait 350 //delay 650ms -> 350ms
832 {0x112cee, 0xff, 0x03},
833 {0x112cef, 0xff, 0x03}, //[12]EN_MSP
834 {0x112cec, 0xff, 0x00}, //[5]QS_LDO_ADC,[3]QS_LDO_DAC
835 {0x112ced, 0xff, 0x18},
836 #endif //End of #if (HW_AutoDepop == 0) // remove for auto depop
837
838 //-----------------Output: SPDIF TX2--------------------//Item 13
839 {0x112c5f, 0x80, 0x80},
840 {0x112c5f, 0x40, 0x40},
841 {0x112c5f, 0x20, 0x00},
842 {0x112c5f, 0x10, 0x00},
843 {0x112c5f, 0x08, 0x00},
844 {0x112c5f, 0x04, 0x00},
845 {0x112c5f, 0x02, 0x00},
846 {0x112c5f, 0x01, 0x00},
847 {0x112c5e, 0x10, 0x10}, //[4]spdif status from DSP/RIU
848 {0x112c5e, 0x08, 0x00},
849 {0x112c5e, 0x04, 0x00},
850 {0x112c5e, 0x03, 0x00},
851 {0x112c5e, 0x80, 0x80},
852 {0x112c5e, 0x40, 0x40},
853 {0x112c5e, 0x20, 0x20},
854 {0xffffff, 0x01, 0x01}, // delay 1ms
855 {0x112c5e, 0x40, 0x00},
856 {0x112c5e, 0x20, 0x00},
857 {0x112c5e, 0x90, 0x90},
858
859 //---------------------------------------------------//Item 30
860 {0x112c94, 0x01, 0x01}, // enable CH1 HW force mute, [0] ch1 mute all
861 {0x112c95, 0x01, 0x01}, // enable CH5 HW force mute, [8] ch5 mute all
862 {0x112c96, 0x01, 0x01}, // enable CH2 HW force mute, [0] ch2 mute all
863 {0x112c97, 0x01, 0x01}, // enable CH6 HW force mute, [8] ch6 mute all
864 {0x112c98, 0x01, 0x01}, // enable CH3 HW force mute, [0] ch3 mute all
865 {0x112c99, 0x01, 0x01}, // enable CH7 HW force mute, [8] ch7 mute all
866 {0x112c9a, 0x01, 0x01}, // enable CH4 HW force mute, [0] ch4 mute all
867 {0x112c9b, 0x01, 0x01}, // enable CH8 HW force mute, [8] ch8 mute all
868
869 //-----------------Interrupt--------------------------//Item 35
870 {0x112aa2, 0x80, 0x00}, //[7]=0 IRQ1E select HDMI TX
871 {0x112ad8, 0x10, 0x20}, //[4]=0 IRQ1E select HDMI TX
872 {0x112aa2, 0x40, 0x40}, //[6:5]=2'b10 IRQ2n select SPDIF TX
873 {0x112aa2, 0x10, 0x00}, //[4]=0 IRQ1L select SPDIF TX2
874 {0x112ad8, 0x20, 0x20}, //[5]=1 IRQ1L select SPDIF TX2
875
876 //-----------------MIU & DMA Setting---------------------------//Item 34
877 {0x112a44, 0xff, 0x00}, //[15] maddma fifo addr demeta
878 {0x112a45, 0xff, 0x80},
879 {0x112ac4, 0xff, 0x00}, //[15] Sedma fifo addr demeta
880 {0x112ac5, 0xff, 0x80},
881 {0x112a21, 0x04, 0x00}, //[10] maddma fifo new mode
882 {0x112aa1, 0x04, 0x00}, //[10] sedma fifo new mode(no function)
883
884 {0x163d03, 0x60, 0x20}, //[14:13] =01 for auR2 use MIU0, =10 for auR2 use MIU1
885 {0x163d07, 0x60, 0x20}, //[14:13] =01 for auR2_1 use MIU0, =10 for auR2_1 use MIU1
886
887 {0x112940, 0x20, 0x00}, //[5] enable R2 Write buffer burst mode
888 {0x163040, 0x20, 0x00}, //[5] enable R2_1 Write buffer burst mode
889
890 {0x112f68, 0xff, 0xff}, // dma arb
891 {0x112f69, 0xff, 0xff},
892 {0x112f66, 0xff, 0x00}, // dma arb
893 {0x112f67, 0xff, 0x00},
894 {0x112f64, 0xff, 0x00}, // dma arb
895 {0x112f65, 0xff, 0x04},
896 {0x112f62, 0xff, 0x08}, // dma arb
897 {0x112f63, 0xff, 0x20},
898 {0x112f60, 0xff, 0x15}, // dma arb
899 {0x112f61, 0xff, 0x80},
900
901 {0x112f88, 0xff, 0xff}, // cache arb
902 {0x112f89, 0xff, 0xff},
903 {0x112f86, 0xff, 0x00}, // cache arb
904 {0x112f87, 0xff, 0x00},
905 {0x112f84, 0xff, 0x00}, // cache arb
906 {0x112f85, 0xff, 0x04},
907 {0x112f82, 0xff, 0x08}, // cache arb
908 {0x112f83, 0xff, 0x20},
909 {0x112f80, 0xff, 0x15}, // cache arb
910 {0x112f81, 0xff, 0x80},
911
912 {0x163d88, 0xff, 0xff}, // R2 arb
913 {0x163d89, 0xff, 0xff},
914 {0x163d86, 0xff, 0x00}, // R2 arb
915 {0x163d87, 0xff, 0x00},
916 {0x163d84, 0xff, 0x00}, // R2 arb
917 {0x163d85, 0xff, 0x04},
918 {0x163d82, 0xff, 0x08}, // R2 arb
919 {0x163d83, 0xff, 0x20},
920 {0x163d80, 0xff, 0x15}, // R2 arb
921 {0x163d81, 0xff, 0x80},
922
923 {0x163da8, 0xff, 0xff}, // R2_1 arb
924 {0x163da9, 0xff, 0xff},
925 {0x163da6, 0xff, 0x00}, // R2_1 arb
926 {0x163da7, 0xff, 0x00},
927 {0x163da4, 0xff, 0x00}, // R2_1 arb
928 {0x163da5, 0xff, 0x04},
929 {0x163da2, 0xff, 0x08}, // R2_1 arb
930 {0x163da3, 0xff, 0x20},
931 {0x163da0, 0xff, 0x15}, // R2_1 arb
932 {0x163da1, 0xff, 0x80},
933
934 {0x163e28, 0xff, 0xff}, // dma_l2 arb
935 {0x163e29, 0xff, 0xff},
936 {0x163e26, 0xff, 0x00}, // dma_l2 arb
937 {0x163e27, 0xff, 0x00},
938 {0x163e24, 0xff, 0x00}, // dma_l2 arb
939 {0x163e25, 0xff, 0x04},
940 {0x163e22, 0xff, 0x08}, // dma_l2 arb
941 {0x163e23, 0xff, 0x20},
942 {0x163e20, 0xff, 0x15}, // dma_l2 arb
943 {0x163e21, 0xff, 0x80},
944
945 //----------------- DFS ---------------------------//Item 36
946 {0x163c61, 0x03, 0x00}, //[9:8] CLK DSP DFS SEL[1:0] = AUPLL
947 {0x163c61, 0x10, 0x00}, //[12] CLK DSP DFS SEL[2] = 0
948 {0x163c61, 0x08, 0x08}, //[11] CLK DSP DFS EN
949 {0x163c60, 0x1f, 0x1f}, //[4:0] DSP DFS DIV
950 {0x163c60, 0x40, 0x40}, //[6] DSP DFS EN
951 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
952 {0x163c60, 0x80, 0x80}, //[7] DSP DFS UPDATE
953 {0x163c60, 0x80, 0x00}, //[7] DSP DFS UPDATE
954 {0x163c63, 0x03, 0x00}, //[9:8] CLK R2 DFS SEL[1:0] = AUR2PLL
955 {0x163c63, 0x10, 0x00}, //[12] CLK R2 DFS SEL[2] = 0
956 {0x163c63, 0x08, 0x08}, //[11] CLK R2 DFS EN
957 {0x163c62, 0x1f, 0x1f}, //[4:0] R2 DFS DIV
958 {0x163c62, 0x40, 0x40}, //[6] R2 DFS EN
959 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
960 {0x163c62, 0x80, 0x80}, //[7] R2 DFS UPDATE
961 {0x163c62, 0x80, 0x00}, //[7] R2 DFS UPDATE
962
963 // ----------------------------------------------------
964 // sound effect init settings
965 //-----------------------------------------------------
966 {0x112D01, 0xFF, 0x8C}, // AUOUT0 volume : 0dB ; Mute @@VVV
967 {0x112D03, 0xFF, 0x8C}, // AUOUT1 volume : 0dB ; Mute @@VVV
968 {0x112D05, 0xFF, 0x8C}, // AUOUT2 volume : 0dB ; Mute @@VVV
969 {0x112D07, 0xFF, 0x8C}, // AUOUT3 volume : 0dB ; Mute @@VVV
970 {0x112D09, 0xFF, 0x8C}, // I2S_OUT volume : 0dB ; Mute @@VVV
971 {0x112D0B, 0xFF, 0x0C}, // SPDIF_OUT volume : 0dB ; UnMute @@VVV
972 // if spdif change to mute, need set g_SPDIF_MuteStatus = 1;
973 {0x112D0F, 0xFF, 0x0C}, // HDMI_OUT volume : 0dB ; UnMute @@VVV
974
975 {0x112D20, 0x80, 0x00}, // Disable EQ @@VVV
976 {0x112D21, 0xFF, 0xC8}, // Enable Sound effect & tone @@VVV
977 {0x112D22, 0x3F, 0x3F}, // Enable all output Volume control @@VVV
978 {0x112D23, 0x01, 0x01}, // Enable SPDIF_OUT volume control @@VVV
979 {0x112D31, 0x02, 0x00}, // disable SE-DSP power-down command @@VVV
980
981 {0x112D50, 0xFF, 0xFF}, // DAC0/1 source default in NULL path @@VVV
982 {0x112D51, 0xFF, 0xFF}, // DAC2/3 source default in NULL path @@VVV
983 {0x112D52, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
984 {0x112D53, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
985 {0x112D54, 0xF0, 0x40}, // SRC source from PCM @@VVV
986
987 {0x112D5D, 0xFF, 0x0C}, // set mix volume of CH5, CH6, CH8 to 0dB
988 {0x112D5C, 0xFF, 0x00},
989 {0x112D5F, 0xFF, 0x0C},
990 {0x112D5E, 0xFF, 0x00},
991 {0x112D5B, 0xFF, 0x0C},
992 {0x112D5A, 0xFF, 0x00},
993
994 {0xffffff, 0x00, 0x00}, // end of table
995
996 };
997
998 const AUDIO_REG_TYPE2 ResetDMIOTbl[]=
999 {
1000 //DMIO a0xx reset
1001 {0x112a80, 0xff, 0x40},
1002 {0x112a81, 0xff, 0x00},
1003 {0x112a80, 0xff, 0x43},
1004 {0x112a81, 0xff, 0x00},
1005 {0x112a84, 0xff, 0x5a},
1006 {0x112a85, 0xff, 0xa0},
1007 {0x112a82, 0xff, 0x00},
1008 {0x112a83, 0xff, 0x00},
1009 {0x112a82, 0xff, 0x80},
1010 {0x112a83, 0xff, 0x00},
1011 {0x112a80, 0xff, 0x53},
1012 {0x112a81, 0xff, 0x00},
1013 {0x112a80, 0xff, 0x43},
1014 {0x112a81, 0xff, 0x00},
1015 {0x112a84, 0xff, 0x5e},
1016 {0x112a85, 0xff, 0xa0},
1017 {0x112a82, 0xff, 0x00},
1018 {0x112a83, 0xff, 0x00},
1019 {0x112a82, 0xff, 0x80},
1020 {0x112a83, 0xff, 0x00},
1021 {0x112a80, 0xff, 0x53},
1022 {0x112a81, 0xff, 0x00},
1023 {0x112a80, 0xff, 0x43},
1024 {0x112a81, 0xff, 0x00},
1025 {0x112a84, 0xff, 0x62},
1026 {0x112a85, 0xff, 0xa0},
1027 {0x112a82, 0xff, 0x00},
1028 {0x112a83, 0xff, 0x00},
1029 {0x112a82, 0xff, 0x80},
1030 {0x112a83, 0xff, 0x00},
1031 {0x112a80, 0xff, 0x53},
1032 {0x112a81, 0xff, 0x00},
1033 {0x112a80, 0xff, 0x43},
1034 {0x112a81, 0xff, 0x00},
1035 {0x112a84, 0xff, 0x66},
1036 {0x112a85, 0xff, 0xa0},
1037 {0x112a82, 0xff, 0x00},
1038 {0x112a83, 0xff, 0x00},
1039 {0x112a82, 0xff, 0x80},
1040 {0x112a83, 0xff, 0x00},
1041 {0x112a80, 0xff, 0x53},
1042 {0x112a81, 0xff, 0x00},
1043 {0x112a80, 0xff, 0x43},
1044 {0x112a81, 0xff, 0x00},
1045 {0x112a84, 0xff, 0x6a},
1046 {0x112a85, 0xff, 0xa0},
1047 {0x112a82, 0xff, 0x00},
1048 {0x112a83, 0xff, 0x00},
1049 {0x112a82, 0xff, 0x80},
1050 {0x112a83, 0xff, 0x00},
1051 {0x112a80, 0xff, 0x53},
1052 {0x112a81, 0xff, 0x00},
1053 {0x112a80, 0xff, 0x43},
1054 {0x112a81, 0xff, 0x00},
1055 {0x112a84, 0xff, 0x6e},
1056 {0x112a85, 0xff, 0xa0},
1057 {0x112a82, 0xff, 0x00},
1058 {0x112a83, 0xff, 0x00},
1059 {0x112a82, 0xff, 0x80},
1060 {0x112a83, 0xff, 0x00},
1061 {0x112a80, 0xff, 0x53},
1062 {0x112a81, 0xff, 0x00},
1063 {0x112a80, 0xff, 0x43},
1064 {0x112a81, 0xff, 0x00},
1065 {0x112a84, 0xff, 0x72},
1066 {0x112a85, 0xff, 0xa0},
1067 {0x112a82, 0xff, 0x00},
1068 {0x112a83, 0xff, 0x00},
1069 {0x112a82, 0xff, 0x80},
1070 {0x112a83, 0xff, 0x00},
1071 {0x112a80, 0xff, 0x53},
1072 {0x112a81, 0xff, 0x00},
1073 {0x112a80, 0xff, 0x43},
1074 {0x112a81, 0xff, 0x00},
1075 {0x112a84, 0xff, 0x76},
1076 {0x112a85, 0xff, 0xa0},
1077 {0x112a82, 0xff, 0x00},
1078 {0x112a83, 0xff, 0x00},
1079 {0x112a82, 0xff, 0x80},
1080 {0x112a83, 0xff, 0x00},
1081 {0x112a80, 0xff, 0x53},
1082 {0x112a81, 0xff, 0x00},
1083 {0x112a80, 0xff, 0x43},
1084 {0x112a81, 0xff, 0x00},
1085 {0x112a84, 0xff, 0x76},
1086 {0x112a85, 0xff, 0xa0},
1087 {0x112a82, 0xff, 0x00},
1088 {0x112a83, 0xff, 0x00},
1089 {0x112a82, 0xff, 0x80},
1090 {0x112a83, 0xff, 0x00},
1091 {0x112a80, 0xff, 0x53},
1092 {0x112a81, 0xff, 0x00},
1093 {0x112a80, 0xff, 0x43},
1094 {0x112a81, 0xff, 0x00},
1095 {0x112a84, 0xff, 0x7a},
1096 {0x112a85, 0xff, 0xa0},
1097 {0x112a82, 0xff, 0x00},
1098 {0x112a83, 0xff, 0x00},
1099 {0x112a82, 0xff, 0x80},
1100 {0x112a83, 0xff, 0x00},
1101 {0x112a80, 0xff, 0x53},
1102 {0x112a81, 0xff, 0x00},
1103 {0x112a80, 0xff, 0x43},
1104 {0x112a81, 0xff, 0x00},
1105 {0x112a84, 0xff, 0x7e},
1106 {0x112a85, 0xff, 0xa0},
1107 {0x112a82, 0xff, 0x00},
1108 {0x112a83, 0xff, 0x00},
1109 {0x112a82, 0xff, 0x80},
1110 {0x112a83, 0xff, 0x00},
1111 {0x112a80, 0xff, 0x53},
1112 {0x112a81, 0xff, 0x00},
1113 {0x112a80, 0xff, 0x43},
1114 {0x112a81, 0xff, 0x00},
1115 {0x112a84, 0xff, 0x82},
1116 {0x112a85, 0xff, 0xa0},
1117 {0x112a82, 0xff, 0x00},
1118 {0x112a83, 0xff, 0x00},
1119 {0x112a82, 0xff, 0x80},
1120 {0x112a83, 0xff, 0x00},
1121 {0x112a80, 0xff, 0x53},
1122 {0x112a81, 0xff, 0x00},
1123 {0x112a80, 0xff, 0x43},
1124 {0x112a81, 0xff, 0x00},
1125 {0x112a84, 0xff, 0x86},
1126 {0x112a85, 0xff, 0xa0},
1127 {0x112a82, 0xff, 0x00},
1128 {0x112a83, 0xff, 0x00},
1129 {0x112a82, 0xff, 0x80},
1130 {0x112a83, 0xff, 0x00},
1131 {0x112a80, 0xff, 0x53},
1132 {0x112a81, 0xff, 0x00},
1133 {0x112a80, 0xff, 0x43},
1134 {0x112a81, 0xff, 0x00},
1135 {0x112a84, 0xff, 0x8a},
1136 {0x112a85, 0xff, 0xa0},
1137 {0x112a82, 0xff, 0x00},
1138 {0x112a83, 0xff, 0x00},
1139 {0x112a82, 0xff, 0x80},
1140 {0x112a83, 0xff, 0x00},
1141 {0x112a80, 0xff, 0x53},
1142 {0x112a81, 0xff, 0x00},
1143 {0x112a80, 0xff, 0x43},
1144 {0x112a81, 0xff, 0x00},
1145 {0x112a84, 0xff, 0xb5},
1146 {0x112a85, 0xff, 0xa0},
1147 {0x112a82, 0xff, 0x00},
1148 {0x112a83, 0xff, 0x00},
1149 {0x112a82, 0xff, 0x80},
1150 {0x112a83, 0xff, 0x00},
1151 {0x112a80, 0xff, 0x53},
1152 {0x112a81, 0xff, 0x00},
1153 {0x112a80, 0xff, 0x43},
1154 {0x112a81, 0xff, 0x00},
1155 {0x112a84, 0xff, 0xe0},
1156 {0x112a85, 0xff, 0xa0},
1157 {0x112a82, 0xff, 0x00},
1158 {0x112a83, 0xff, 0x00},
1159 {0x112a82, 0xff, 0x80},
1160 {0x112a83, 0xff, 0x00},
1161 {0x112a80, 0xff, 0x53},
1162 {0x112a81, 0xff, 0x00},
1163 {0x112a80, 0xff, 0x43},
1164 {0x112a81, 0xff, 0x00},
1165 {0x112a84, 0xff, 0x7a},
1166 {0x112a85, 0xff, 0xa1},
1167 {0x112a82, 0xff, 0x00},
1168 {0x112a83, 0xff, 0x00},
1169 {0x112a82, 0xff, 0x80},
1170 {0x112a83, 0xff, 0x00},
1171 {0x112a80, 0xff, 0x53},
1172 {0x112a81, 0xff, 0x00},
1173 {0x112a80, 0xff, 0x43},
1174 {0x112a81, 0xff, 0x00},
1175 {0x112a84, 0xff, 0x7e},
1176 {0x112a85, 0xff, 0xa1},
1177 {0x112a82, 0xff, 0x00},
1178 {0x112a83, 0xff, 0x00},
1179 {0x112a82, 0xff, 0x80},
1180 {0x112a83, 0xff, 0x00},
1181 {0x112a80, 0xff, 0x53},
1182 {0x112a81, 0xff, 0x00},
1183 {0x112a80, 0xff, 0x43},
1184 {0x112a81, 0xff, 0x00},
1185 {0x112a84, 0xff, 0x82},
1186 {0x112a85, 0xff, 0xa1},
1187 {0x112a82, 0xff, 0x00},
1188 {0x112a83, 0xff, 0x00},
1189 {0x112a82, 0xff, 0x80},
1190 {0x112a83, 0xff, 0x00},
1191 {0x112a80, 0xff, 0x53},
1192 {0x112a81, 0xff, 0x00},
1193 {0x112a80, 0xff, 0x43},
1194 {0x112a81, 0xff, 0x00},
1195 {0x112a84, 0xff, 0x86},
1196 {0x112a85, 0xff, 0xa1},
1197 {0x112a82, 0xff, 0x00},
1198 {0x112a83, 0xff, 0x00},
1199 {0x112a82, 0xff, 0x80},
1200 {0x112a83, 0xff, 0x00},
1201 {0x112a80, 0xff, 0x53},
1202 {0x112a81, 0xff, 0x00},
1203 {0x112a80, 0xff, 0x43},
1204 {0x112a81, 0xff, 0x00},
1205 {0x112a84, 0xff, 0x8a},
1206 {0x112a85, 0xff, 0xa1},
1207 {0x112a82, 0xff, 0x00},
1208 {0x112a83, 0xff, 0x00},
1209 {0x112a82, 0xff, 0x80},
1210 {0x112a83, 0xff, 0x00},
1211 {0x112a80, 0xff, 0x53},
1212 {0x112a81, 0xff, 0x00},
1213 {0x112a80, 0xff, 0x43},
1214 {0x112a81, 0xff, 0x00},
1215 {0x112a84, 0xff, 0x76},
1216 {0x112a85, 0xff, 0xa1},
1217 {0x112a82, 0xff, 0x00},
1218 {0x112a83, 0xff, 0x00},
1219 {0x112a82, 0xff, 0x80},
1220 {0x112a83, 0xff, 0x00},
1221 {0x112a80, 0xff, 0x53},
1222 {0x112a81, 0xff, 0x00},
1223 {0x112a80, 0xff, 0x43},
1224 {0x112a81, 0xff, 0x00},
1225 {0x112a84, 0xff, 0xe0},
1226 {0x112a85, 0xff, 0xa1},
1227 {0x112a82, 0xff, 0x00},
1228 {0x112a83, 0xff, 0x00},
1229 {0x112a82, 0xff, 0x80},
1230 {0x112a83, 0xff, 0x00},
1231 {0x112a80, 0xff, 0x53},
1232 {0x112a81, 0xff, 0x00},
1233 {0x112a80, 0xff, 0x43},
1234 {0x112a81, 0xff, 0x00},
1235 {0x112a84, 0xff, 0xe8},
1236 {0x112a85, 0xff, 0xa1},
1237 {0x112a82, 0xff, 0x00},
1238 {0x112a83, 0xff, 0x00},
1239 {0x112a82, 0xff, 0x80},
1240 {0x112a83, 0xff, 0x00},
1241 {0x112a80, 0xff, 0x53},
1242 {0x112a81, 0xff, 0x00},
1243 {0x112a80, 0xff, 0x43},
1244 {0x112a81, 0xff, 0x00},
1245 {0x112a80, 0xff, 0x00},
1246 {0x112a81, 0xff, 0x00},
1247 {0x112c00, 0xff, 0x01},
1248 {0x112c01, 0xff, 0x01},
1249 {0x112c00, 0xff, 0x00},
1250 {0x112c01, 0xff, 0x00},
1251 //end DMIO a0xx reset
1252 {0xffffff, 0x00, 0x00}, // end of table
1253 };
1254
1255 #if AUDIO_HW_DMA_READER1_SUPPORT
1256 AUDIO_PCM_t Audio_Pcm_HwDma_Reader1 = {
1257 .u8Name = AUDIO_HW_DMA_READER1,
1258 .tPcmOps = {
1259 .open = HAL_AUDIO_PCM_HwDma_Reader1_Open,
1260 .close = HAL_AUDIO_PCM_HwDma_Reader1_Close,
1261 .start = HAL_AUDIO_PCM_HwDma_Reader1_Start,
1262 .stop = HAL_AUDIO_PCM_HwDma_Reader1_Stop,
1263 .set = HAL_AUDIO_PCM_HwDma_Reader1_Set,
1264 .get = HAL_AUDIO_PCM_HwDma_Reader1_Get,
1265 .read = NULL,
1266 .write = HAL_AUDIO_PCM_HwDma_Reader1_Write,
1267 .flush = HAL_AUDIO_PCM_HwDma_Reader1_Flush,
1268 },
1269 .tPcmCaps = {
1270 .u8MultiChFlag = FALSE,
1271 .u8MixingFlag = FALSE,
1272 .u8CaptureFlag = FALSE,
1273 .u32Channel = {1, 2},
1274 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1275 .u32BitWidth = {16},
1276 },
1277 };
1278 #endif
1279
1280 #if AUDIO_HW_DMA_READER2_SUPPORT
1281 AUDIO_PCM_t Audio_Pcm_HwDma_Reader2 = {
1282 .u8Name = AUDIO_HW_DMA_READER2,
1283 .tPcmOps = {
1284 .open = HAL_AUDIO_PCM_HwDma_Reader2_Open,
1285 .close = HAL_AUDIO_PCM_HwDma_Reader2_Close,
1286 .start = HAL_AUDIO_PCM_HwDma_Reader2_Start,
1287 .stop = HAL_AUDIO_PCM_HwDma_Reader2_Stop,
1288 .set = HAL_AUDIO_PCM_HwDma_Reader2_Set,
1289 .get = HAL_AUDIO_PCM_HwDma_Reader2_Get,
1290 .read = NULL,
1291 .write = HAL_AUDIO_PCM_HwDma_Reader2_Write,
1292 .flush = HAL_AUDIO_PCM_HwDma_Reader2_Flush,
1293 },
1294 .tPcmCaps = {
1295 .u8MultiChFlag = FALSE,
1296 .u8MixingFlag = FALSE,
1297 .u8CaptureFlag = FALSE,
1298 .u32Channel = {1, 2},
1299 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1300 .u32BitWidth = {16},
1301 },
1302 };
1303 #endif
1304
1305 #if AUDIO_SW_DMA_READER1_SUPPORT
1306 AUDIO_PCM_t Audio_Pcm_SwDma_Reader1 = {
1307 .u8Name = AUDIO_SW_DMA_READER1,
1308 .tPcmOps = {
1309 .open = HAL_AUDIO_PCM_SwDma_Reader1_Open,
1310 .close = HAL_AUDIO_PCM_SwDma_Reader1_Close,
1311 .start = HAL_AUDIO_PCM_SwDma_Reader1_Start,
1312 .stop = HAL_AUDIO_PCM_SwDma_Reader1_Stop,
1313 .set = HAL_AUDIO_PCM_SwDma_Reader1_Set,
1314 .get = HAL_AUDIO_PCM_SwDma_Reader1_Get,
1315 .read = NULL,
1316 .write = HAL_AUDIO_PCM_SwDma_Reader1_Write,
1317 .flush = HAL_AUDIO_PCM_SwDma_Reader1_Flush,
1318 },
1319 .tPcmCaps = {
1320 .u8MultiChFlag = FALSE,
1321 .u8MixingFlag = FALSE,
1322 .u8CaptureFlag = FALSE,
1323 .u32Channel = {1, 2},
1324 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
1325 .u32BitWidth = {16},
1326 },
1327 };
1328 #endif
1329
1330 #if AUDIO_R2_DMA_READER1_SUPPORT
1331 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader1 = {
1332 .u8Name = AUDIO_R2_DMA_READER1,
1333 .tPcmOps = {
1334 .open = HAL_AUDIO_PCM_R2Dma_Reader1_Open,
1335 .close = HAL_AUDIO_PCM_R2Dma_Reader1_Close,
1336 .start = HAL_AUDIO_PCM_R2Dma_Reader1_Start,
1337 .stop = HAL_AUDIO_PCM_R2Dma_Reader1_Stop,
1338 .set = HAL_AUDIO_PCM_R2Dma_Reader1_Set,
1339 .get = HAL_AUDIO_PCM_R2Dma_Reader1_Get,
1340 .read = NULL,
1341 .write = HAL_AUDIO_PCM_R2Dma_Reader1_Write,
1342 .flush = HAL_AUDIO_PCM_R2Dma_Reader1_Flush,
1343 },
1344 .tPcmCaps = {
1345 .u8MultiChFlag = TRUE,
1346 .u8MixingFlag = FALSE,
1347 .u8CaptureFlag = FALSE,
1348 .u32Channel = {1, 2, 10},
1349 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1350 .u32BitWidth = {16},
1351 },
1352 };
1353 #endif
1354
1355 #if AUDIO_R2_DMA_READER2_SUPPORT
1356 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader2 = {
1357 .u8Name = AUDIO_R2_DMA_READER2,
1358 .tPcmOps = {
1359 .open = HAL_AUDIO_PCM_R2Dma_Reader2_Open,
1360 .close = HAL_AUDIO_PCM_R2Dma_Reader2_Close,
1361 .start = HAL_AUDIO_PCM_R2Dma_Reader2_Start,
1362 .stop = HAL_AUDIO_PCM_R2Dma_Reader2_Stop,
1363 .set = HAL_AUDIO_PCM_R2Dma_Reader2_Set,
1364 .get = HAL_AUDIO_PCM_R2Dma_Reader2_Get,
1365 .read = NULL,
1366 .write = HAL_AUDIO_PCM_R2Dma_Reader2_Write,
1367 .flush = HAL_AUDIO_PCM_R2Dma_Reader2_Flush,
1368 },
1369 .tPcmCaps = {
1370 .u8MultiChFlag = TRUE,
1371 .u8MixingFlag = FALSE,
1372 .u8CaptureFlag = FALSE,
1373 .u32Channel = {1, 2, 10},
1374 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1375 .u32BitWidth = {16},
1376 },
1377 };
1378 #endif
1379
1380 #if AUDIO_PCM_CAPTURE1_SUPPORT
1381 AUDIO_PCM_t Audio_Pcm_Capture1 = {
1382 .u8Name = AUDIO_PCM_CAPTURE1,
1383 .tPcmOps = {
1384 .open = HAL_AUDIO_PCM_Capture1_Open,
1385 .close = HAL_AUDIO_PCM_Capture1_Close,
1386 .start = HAL_AUDIO_PCM_Capture1_Start,
1387 .stop = HAL_AUDIO_PCM_Capture1_Stop,
1388 .set = HAL_AUDIO_PCM_Capture1_Set,
1389 .get = HAL_AUDIO_PCM_Capture1_Get,
1390 .read = HAL_AUDIO_PCM_Capture1_Read,
1391 .write = NULL,
1392 .flush = HAL_AUDIO_PCM_Capture1_Flush,
1393 },
1394 .tPcmCaps = {
1395 .u8MultiChFlag = FALSE,
1396 .u8MixingFlag = FALSE,
1397 .u8CaptureFlag = TRUE,
1398 .u32Channel = {2},
1399 .u32SampleRate = {48000},
1400 .u32BitWidth = {16},
1401 },
1402 };
1403 #endif
1404
1405 #if AUDIO_PCM_CAPTURE2_SUPPORT
1406 AUDIO_PCM_t Audio_Pcm_Capture2 = {
1407 .u8Name = AUDIO_PCM_CAPTURE2,
1408 .tPcmOps = {
1409 .open = HAL_AUDIO_PCM_Capture2_Open,
1410 .close = HAL_AUDIO_PCM_Capture2_Close,
1411 .start = HAL_AUDIO_PCM_Capture2_Start,
1412 .stop = HAL_AUDIO_PCM_Capture2_Stop,
1413 .set = HAL_AUDIO_PCM_Capture2_Set,
1414 .get = HAL_AUDIO_PCM_Capture2_Get,
1415 .read = HAL_AUDIO_PCM_Capture2_Read,
1416 .write = NULL,
1417 .flush = HAL_AUDIO_PCM_Capture2_Flush,
1418 },
1419 .tPcmCaps = {
1420 .u8MultiChFlag = FALSE,
1421 .u8MixingFlag = FALSE,
1422 .u8CaptureFlag = TRUE,
1423 .u32Channel = {2},
1424 .u32SampleRate = {48000},
1425 .u32BitWidth = {16},
1426 },
1427 };
1428 #endif
1429
1430 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1431 AUDIO_PCM_t Audio_Pcm_HwDma_Writer1 = {
1432 .u8Name = AUDIO_HW_DMA_WRITER1,
1433 .tPcmOps = {
1434 .open = HAL_AUDIO_PCM_HwDma_Writer1_Open,
1435 .close = HAL_AUDIO_PCM_HwDma_Writer1_Close,
1436 .start = HAL_AUDIO_PCM_HwDma_Writer1_Start,
1437 .stop = HAL_AUDIO_PCM_HwDma_Writer1_Stop,
1438 .set = HAL_AUDIO_PCM_HwDma_Writer1_Set,
1439 .get = HAL_AUDIO_PCM_HwDma_Writer1_Get,
1440 .read = HAL_AUDIO_PCM_HwDma_Writer1_Read,
1441 .write = NULL,
1442 .flush = HAL_AUDIO_PCM_HwDma_Writer1_Flush,
1443 },
1444 .tPcmCaps = {
1445 .u8MultiChFlag = FALSE,
1446 .u8MixingFlag = FALSE,
1447 .u8CaptureFlag = TRUE,
1448 .u32Channel = {2},
1449 .u32SampleRate = {48000},
1450 .u32BitWidth = {16},
1451 },
1452 };
1453 #endif
1454
1455 MS_U8 g_Common_PCM_IO_Init = FALSE;
1456
1457 AUDIO_PCM_t *g_PCM[AUDIO_PCM_MAXNUM] = {
1458 #if AUDIO_HW_DMA_READER1_SUPPORT
1459 &Audio_Pcm_HwDma_Reader1,
1460 #endif
1461 #if AUDIO_HW_DMA_READER2_SUPPORT
1462 &Audio_Pcm_HwDma_Reader2,
1463 #endif
1464 #if AUDIO_SW_DMA_READER1_SUPPORT
1465 &Audio_Pcm_SwDma_Reader1,
1466 #endif
1467 #if AUDIO_R2_DMA_READER1_SUPPORT
1468 &Audio_Pcm_R2Dma_Reader1,
1469 #endif
1470 #if AUDIO_R2_DMA_READER2_SUPPORT
1471 &Audio_Pcm_R2Dma_Reader2,
1472 #endif
1473 #if AUDIO_PCM_CAPTURE1_SUPPORT
1474 &Audio_Pcm_Capture1,
1475 #endif
1476 #if AUDIO_PCM_CAPTURE2_SUPPORT
1477 &Audio_Pcm_Capture2,
1478 #endif
1479 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1480 &Audio_Pcm_HwDma_Writer1,
1481 #endif
1482 };
1483
1484
1485 //-------------------------------------------------------------------------------------------------
1486 // Debug Functions
1487 //-------------------------------------------------------------------------------------------------
1488
1489 //-------------------------------------------------------------------------------------------------
1490 // Local Functions
1491 //-------------------------------------------------------------------------------------------------
1492
1493 ////////////////////////////////////////////////////////////////////////////////
1494 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus()
1495 /// @brief \b Function \b Description: Return audio status.
1496 /// @return MS_U16 \b : return structure which include pcm, non pcm, sampling rate.
1497 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus(ST_HDMI_AUDIO_STATUS * p_hdmiAudioSts)1498 MS_BOOL HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus( ST_HDMI_AUDIO_STATUS *p_hdmiAudioSts)
1499 {
1500 MS_BOOL ret = TRUE;
1501
1502 if (HAL_AUDIO_HDMI_NonpcmMonitor())
1503 {
1504 switch(HAL_AUDIO_HDMI_DolbyMonitor())
1505 {
1506 case 0x01: p_hdmiAudioSts->audio_type = HDMI_RX_DD; break;
1507 case 0x0b: p_hdmiAudioSts->audio_type = HDMI_RX_DTS; break;
1508 case 0x15: p_hdmiAudioSts->audio_type = HDMI_RX_DDP; break;
1509 default: p_hdmiAudioSts->audio_type = HDMI_RX_Other; break;
1510 }
1511 }
1512 else
1513 p_hdmiAudioSts->audio_type = HDMI_RX_PCM;
1514
1515 p_hdmiAudioSts->sampleRate = AUDIO_FS_48KHZ;
1516
1517 return ret;
1518
1519 }
1520
HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)1521 MS_BOOL HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)
1522 {
1523 int i = 0;
1524 int array_mount = 0;
1525
1526 if (pAUDIOShared == NULL)
1527 {
1528 return FALSE;
1529 }
1530
1531 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1532
1533 /* Fill in default value */
1534 pAUDIOShared->g_DspCodeType = AU_DVB_STANDARD_INVALID;
1535 pAUDIOShared->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
1536 pAUDIOShared->g_u8MADSkipResetFlag = FALSE;
1537 pAUDIOShared->g_u8MAD2SkipResetFlag = FALSE;
1538 pAUDIOShared->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
1539 pAUDIOShared->g_u8DspAliveFlag = TRUE;
1540 pAUDIOShared->g_eSpdifOutputType = SPDIF_OUT_NONE;
1541 pAUDIOShared->g_SpdifNpcmPath = AUDIO_DSP_ID_ALL;
1542
1543 pAUDIOShared->g_u8SifDspType = DSP_SE;
1544 pAUDIOShared->g_dolby_truehd_enable = FALSE;
1545 pAUDIOShared->g_PreMainDspCodeType = AU_DVB_STANDARD_INVALID;
1546
1547 array_mount = sizeof(pAUDIOShared->sif_gain_0) / sizeof(pAUDIOShared->sif_gain_0[0]);
1548 for (i = 0; i < array_mount; i++)
1549 {
1550 /* Note! sif_gain_0[] is expected same length as sif_shift_0[] */
1551 pAUDIOShared->sif_gain_0[i] = 0x7FFF;
1552 pAUDIOShared->sif_shift_0[i] = 0x0000;
1553 }
1554 pAUDIOShared->g_u8IntTag = 1;
1555 pAUDIOShared->int_mb_cnt = 0;
1556
1557 pAUDIOShared->CompressInfo = 0;
1558 for ( i = 0; i < MAX_AUDIO_BASE_ADDRESS_NUM2; i++ )
1559 {
1560 pAUDIOShared->g_DSPMadMIUBank[i] = g_DSPMadMIUBank[i];
1561 pAUDIOShared->g_DSPBinBaseAddress[i] = g_DSPBinBaseAddress[i];
1562 pAUDIOShared->g_DSPMadBaseBufferAdr[i] = g_DSPMadBaseBufferAdr[i];
1563 pAUDIOShared->g_DSPDDRBinBaseAddress[i] = g_DSPDDRBinBaseAddress[i];
1564 }
1565
1566 pAUDIOShared->eMainSourceType = E_AUDIO_INFO_DTV_IN;
1567 pAUDIOShared->ePrevSourceType = E_AUDIO_INFO_DTV_IN;
1568
1569 pAUDIOShared->eAudioSource = E_AUDIO_INFO_ADC_IN;
1570 pAUDIOShared->eMainAudioSource = AUDIO_NULL_INPUT;
1571 pAUDIOShared->eSubAudioSource = AUDIO_NULL_INPUT;
1572 pAUDIOShared->eScartAudioSource = AUDIO_NULL_INPUT;
1573
1574 pAUDIOShared->g_SPDIF_MuteStatus = 0;
1575
1576 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1577 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8R2NonPcmSetting = 0x00;
1578 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1579 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1580
1581 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1582 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8R2NonPcmSetting = 0x00;
1583 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1584 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1585
1586 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1587 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8R2NonPcmSetting = 0x00;
1588 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1589 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1590
1591 pAUDIOShared->g_dolbyLoudness_DTVsystem = DVB_MODE;
1592 pAUDIOShared->g_dolbyLoudness_Enable = 1;
1593 /* 1st decoder (depends on chip) */
1594 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsVersion = AUD_CAP_VERSION;
1595 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1596 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum = 2;
1597 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDmaReaderNum = 2;
1598 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsADSupported = TRUE;
1599 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsPusiDetectSupported = FALSE;
1600 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMpegSupported = TRUE;
1601 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3Supported = TRUE;
1602 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3pSupported = TRUE;
1603 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAacSupported = TRUE;
1604 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMp3Supported = TRUE;
1605 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaSupported = TRUE;
1606 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsRa8LbrSupported = TRUE;
1607 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsXpcmSupported = TRUE;
1608 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsSupported = TRUE;
1609 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaProSupported = TRUE;
1610 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsFlacSupported = TRUE;
1611 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsVorbisSupported = TRUE;
1612 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsLbrSupported = TRUE;
1613 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrNbSupported = TRUE;
1614 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrWbSupported = TRUE;
1615 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDraSupported = TRUE;
1616
1617 /* 2nd decoder (depends on chip) */
1618 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsVersion = AUD_CAP_VERSION;
1619 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1620 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDecoderNum = 2;
1621 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDmaReaderNum = 2;
1622 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsADSupported = TRUE;
1623 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsPusiDetectSupported = FALSE;
1624 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMpegSupported = TRUE;
1625 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3Supported = TRUE;
1626 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3pSupported = TRUE;
1627 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAacSupported = TRUE;
1628 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMp3Supported = TRUE;
1629 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaSupported = TRUE;
1630 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsRa8LbrSupported = TRUE;
1631 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsXpcmSupported = TRUE;
1632 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsSupported = TRUE;
1633 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaProSupported = TRUE;
1634 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsFlacSupported = TRUE;
1635 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsVorbisSupported = TRUE;
1636 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsLbrSupported = TRUE;
1637 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrNbSupported = TRUE;
1638 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrWbSupported = TRUE;
1639 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDraSupported = TRUE;
1640
1641 return TRUE;
1642 }
1643
HAL_AUDIO_AllocateVars(void)1644 AUDIO_SHARED_VARS2 * HAL_AUDIO_AllocateVars(void)
1645 {
1646 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1647
1648 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1649 MS_U32 u32ShmId = 0;
1650 AUDIO_SHARED_VARS2 * virtAddr = 0;
1651 MS_U32 u32BufSize = 0;
1652
1653 HALAUDIO_ERROR("Start %s InitShmFlag=%d\r\n", __FUNCTION__, g_bInitShmFlag);
1654
1655 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
1656 {
1657 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1658
1659 HALAUDIO_ERROR("%s QUERY ClientCounter=%d\r\n", __FUNCTION__, pAUDIOShared->g_u32ClientCounter);
1660
1661 if (pAUDIOShared->g_u32ClientCounter == 0)
1662 {
1663 HALAUDIO_ERROR("Resume from Suspend mode, reset Audio SHM data ...\n");
1664 }
1665 }
1666 else
1667 {
1668 HALAUDIO_ERROR("create Audio SHM data ...\n");
1669
1670 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
1671 {
1672 HALAUDIO_ERROR("Audio SHM data is created\n");
1673 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1674
1675 HALAUDIO_ERROR("reset Audio SHM data ...\n");
1676 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1677 }
1678 else
1679 {
1680 HALAUDIO_ERROR("AUDIO SHM allocation failed!\n");
1681 return NULL;
1682 }
1683 }
1684
1685 if (g_bInitShmFlag == FALSE)
1686 {
1687 g_bInitShmFlag = TRUE;
1688 pAUDIOShared->g_u32ClientCounter++;
1689 }
1690
1691 HALAUDIO_ERROR("End %s InitShmFlag=%d, ClientCounter=%d \r\n", __FUNCTION__, g_bInitShmFlag, pAUDIOShared->g_u32ClientCounter);
1692
1693 #else
1694 pAUDIOShared = &g_audioShared;
1695
1696 if (g_bInitShmFlag == FALSE)
1697 {
1698 HALAUDIO_PRINT("create Audio SHM data ...\n");
1699 g_bInitShmFlag = TRUE;
1700
1701 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1702
1703 pAUDIOShared->g_u32ClientCounter++;
1704 }
1705 #endif
1706
1707 gOpenDecodeSystemFuncPtr = HAL_AUDIO_OpenDecodeSystem;
1708 gDigitalOutChannelStatusFuncPtr = HAL_AUDIO_DigitalOut_SetChannelStatus;
1709 pFuncPtr_Setsystem = HAL_AUDIO_SetDecodeSystem;
1710 gGetDDRInfoFuncPtr = HAL_AUDIO_GetDDRInfo;
1711
1712 return pAUDIOShared;
1713 }
1714
HAL_AUDIO_DeAllocateVars(void)1715 MS_BOOL HAL_AUDIO_DeAllocateVars(void)
1716 {
1717 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1718
1719 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1720 MS_U32 u32ShmId = 0;
1721 AUDIO_SHARED_VARS2 * virtAddr = 0;
1722 MS_U32 u32BufSize = 0;
1723
1724 HALAUDIO_ERROR("Start HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1725
1726 if (g_bInitShmFlag == TRUE)
1727 {
1728 g_bInitShmFlag = FALSE;
1729
1730 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
1731 {
1732 HALAUDIO_ERROR("%s() : No AUDIO SHM is created!\n", __FUNCTION__);
1733 return FALSE;
1734 }
1735
1736 pAUDIOShared = (AUDIO_SHARED_VARS2 *)virtAddr;
1737 pAUDIOShared->g_u32ClientCounter--;
1738
1739 HALAUDIO_ERROR("HAL_AUDIO_DeAllocateVars ClientCounter=%d\r\n", pAUDIOShared->g_u32ClientCounter);
1740
1741 if (pAUDIOShared->g_u32ClientCounter == 0)
1742 {
1743 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1744
1745 HALAUDIO_ERROR("free Audio SHM data ...\n");
1746 #if defined(MSOS_TYPE_LINUX)
1747 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_SHM_NAME, u32ShmId) == TRUE)
1748 {
1749 HALAUDIO_ERROR("Audio SHM data is freed\n");
1750 }
1751 else
1752 {
1753 HALAUDIO_ERROR("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1754 return FALSE;
1755 }
1756 #endif
1757
1758 HAL_AUDIO_Mutex_DeInit();
1759 }
1760 /* patch for DC off/on no sound issue start */
1761 else
1762 {
1763 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1764 }
1765 /* patch for DC off/on no sound issue end */
1766 }
1767
1768 HALAUDIO_ERROR("End HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1769 #else
1770 pAUDIOShared = &g_audioShared;
1771
1772 if (g_bInitShmFlag == TRUE)
1773 {
1774 HALAUDIO_PRINT("free Audio SHM data ...\n");
1775 g_bInitShmFlag = FALSE;
1776
1777 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1778 }
1779 #endif
1780
1781 return TRUE;
1782 }
1783
1784 ////////////////////////////////////////////////////////////////////////////////
1785 /// @brief \b Function \b Name: HAL_AUDIO_InitialVars()
1786 /// @brief \b Function \b Description: This routine set audio share memory of Aduio module.
1787 /// @param <IN> \b NONE :
1788 /// @param <OUT> \b NONE :
1789 /// @param <RET> \b NONE :
1790 /// @param <GLOBAL> \b NONE :
1791 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_InitialVars(void)1792 MS_BOOL HAL_AUDIO_InitialVars(void)
1793 {
1794 if (HAL_AUDIO_GET_INIT_FLAG() == FALSE)
1795 {
1796 g_AudioVars2 = HAL_AUDIO_AllocateVars();
1797 if (g_AudioVars2 == NULL)
1798 {
1799 return FALSE;
1800 }
1801
1802 #ifndef MSOS_TYPE_NUTTX
1803 pAudioTeeInfoShm = HAL_AUDIO_AllocateTeeInfoShm();
1804 if (pAudioTeeInfoShm == NULL)
1805 {
1806 HALAUDIO_ERROR("Create Audio TEE INFO SHM data fail...\n");
1807 return FALSE;
1808 }
1809 }
1810 #else
1811 {
1812 MS_U8 audio_mbx_class=0;
1813
1814 MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "MAD", (MS_U8 *)&audio_mbx_class);
1815 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(audio_mbx_class, 10, HAL_AUDIO_HandleDynamicMBX))
1816 {
1817 HALAUDIO_ERROR("MAD Register MBX MSG error\n");
1818 return FALSE;
1819 }
1820 else
1821 DBG_AUDIO("MAD MBX register msg ok %d\n", audio_mbx_class);
1822
1823 _s32MadEventId = MsOS_CreateEventGroup("MAD_Event");
1824 if (_s32MadEventId < 0)
1825 {
1826 HALAUDIO_ERROR("MAD CreateEventGroup error....\n");
1827 return FALSE;
1828 }
1829
1830 _s32MadTaskId = MsOS_CreateTask((TaskEntry)_MAD_Proc,
1831 NULL,
1832 E_TASK_PRI_MEDIUM,
1833 TRUE,
1834 NULL,
1835 32, // stack size..
1836 "MAD_ISR_Task");
1837 if (_s32MadTaskId < 0)
1838 {
1839 MsOS_DeleteEventGroup(_s32MadEventId);
1840 HALAUDIO_ERROR("MAD CreateTask error....\n");
1841 return FALSE;
1842 }
1843 }
1844 }
1845 #endif
1846
1847 return TRUE;
1848 }
1849
1850 ////////////////////////////////////////////////////////////////////////////////
1851 /// @brief \b Function \b Name: HAL_AUDIO_DeInitialVars()
1852 /// @brief \b Function \b Description: This routine delete audio share memory of Aduio module.
1853 /// @param <IN> \b NONE :
1854 /// @param <OUT> \b NONE :
1855 /// @param <RET> \b NONE :
1856 /// @param <GLOBAL> \b NONE :
1857 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DeInitialVars(void)1858 MS_BOOL HAL_AUDIO_DeInitialVars(void)
1859 {
1860 MS_BOOL ret = TRUE;
1861
1862 if (HAL_AUDIO_GET_INIT_FLAG() == TRUE)
1863 {
1864 HAL_AUDIO_SET_INIT_FLAG(FALSE);
1865
1866 ret = HAL_AUDIO_DeAllocateVars();
1867 if (ret == FALSE)
1868 {
1869 HALAUDIO_ERROR ("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1870 }
1871
1872 #if 0 /* patch for STR resume segmentation fault issue */
1873 g_AudioVars2 = NULL;
1874 #endif
1875
1876 #ifndef MSOS_TYPE_NUTTX
1877 {
1878 MS_BOOL ret1;
1879
1880 ret1 = HAL_AUDIO_DeAllocateTeeInfoShm();
1881 if (ret1 == FALSE)
1882 {
1883 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
1884 ret = FALSE;
1885 }
1886 }
1887 #endif
1888 }
1889
1890 return ret;
1891 }
1892
1893 ////////////////////////////////////////////////////////////////////////////////
1894 /// @brief \b Function \b Name: HAL_AUDIO_SET_INIT_FLAG()
1895 /// @brief \b Function \b Description: This routine set the initial status of Aduio module.
1896 /// @param <IN> \b NONE :
1897 /// @param <OUT> \b NONE :
1898 /// @param <RET> \b MS_BOOL :
1899 /// @param <GLOBAL> \b NONE :
1900 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)1901 void HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)
1902 {
1903 HALAUDIO_CHECK_SHM_INIT;
1904
1905 g_AudioVars2->g_Audio_InitFlag = bSet;
1906
1907 return;
1908 }
1909
1910 ////////////////////////////////////////////////////////////////////////////////
1911 /// @brief \b Function \b Name: HAL_AUDIO_GET_INIT_FLAG()
1912 /// @brief \b Function \b Description: This routine get the initial status of Aduio module.
1913 /// @param <IN> \b NONE :
1914 /// @param <OUT> \b NONE :
1915 /// @param <RET> \b MS_BOOL :
1916 /// @param <GLOBAL> \b NONE :
1917 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GET_INIT_FLAG(void)1918 MS_BOOL HAL_AUDIO_GET_INIT_FLAG(void)
1919 {
1920 if (g_AudioVars2 == NULL)
1921 {
1922 return FALSE;
1923 }
1924
1925 return g_AudioVars2->g_Audio_InitFlag;
1926 }
1927
1928 ////////////////////////////////////////////////////////////////////////////////
1929 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_Init()
1930 /// @brief \b Function \b Description: This routine is the initialization of Mutex for Audio module.
1931 /// @param <IN> \b NONE :
1932 /// @param <OUT> \b NONE :
1933 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
1934 /// @param <GLOBAL> \b NONE :
1935 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_Init(void)1936 MS_BOOL HAL_AUDIO_Mutex_Init(void)
1937 {
1938 MS_BOOL ret = TRUE;
1939
1940 if ((_s32AUDIOMutex != -1) &&
1941 (_s32AUDIOMutexReboot != -1) &&
1942 (_s32MutexLoadCode != -1) &&
1943 (_s32AUDIOMutexIDMA != -1))
1944 {
1945 return ret;
1946 }
1947
1948 if (_s32AUDIOMutex == -1)
1949 {
1950 _s32AUDIOMutex = OS_CREATE_MUTEX(AUDIO);
1951 if (_s32AUDIOMutex == -1)
1952 {
1953 HALAUDIO_ERROR("Error! Create Mutex failed!\n");
1954 ret = FALSE;
1955 }
1956 }
1957
1958 if (_s32AUDIOMutexReboot == -1)
1959 {
1960 _s32AUDIOMutexReboot = OS_CREATE_MUTEX(AUDIOreboot);
1961 if (_s32AUDIOMutexReboot == -1)
1962 {
1963 HALAUDIO_ERROR("Error! Create Mutex for Reboot failed!\n");
1964 ret = FALSE;
1965 }
1966 }
1967
1968 if (_s32MutexLoadCode == -1)
1969 {
1970 _s32MutexLoadCode = OS_CREATE_MUTEX(LOAD_DECDSP);
1971 if (_s32MutexLoadCode == -1)
1972 {
1973 HALAUDIO_ERROR("Error! Create Mutex for Load DSP failed!\n");
1974 ret = FALSE;
1975 }
1976 }
1977
1978 if (_s32AUDIOMutexIDMA == -1)
1979 {
1980 _s32AUDIOMutexIDMA = OS_CREATE_MUTEX(AUDIO_IDMA);
1981 if (_s32AUDIOMutexIDMA == -1)
1982 {
1983 HALAUDIO_ERROR("Error! Create Mutex for IMDA failed!\n");
1984 ret = FALSE;
1985 }
1986 }
1987
1988 if (ret == FALSE)
1989 {
1990 if (_s32AUDIOMutex != -1)
1991 {
1992 OS_DELETE_MUTEX(_s32AUDIOMutex);
1993 _s32AUDIOMutex = -1;
1994 }
1995
1996 if (_s32AUDIOMutexReboot != -1)
1997 {
1998 OS_DELETE_MUTEX(_s32AUDIOMutexReboot);
1999 _s32AUDIOMutexReboot = -1;
2000 }
2001
2002 if (_s32MutexLoadCode != -1)
2003 {
2004 OS_DELETE_MUTEX(_s32MutexLoadCode);
2005 _s32MutexLoadCode = -1;
2006 }
2007
2008 if (_s32AUDIOMutexIDMA != -1)
2009 {
2010 OS_DELETE_MUTEX(_s32AUDIOMutexIDMA);
2011 _s32AUDIOMutexIDMA = -1;
2012 }
2013 }
2014
2015 return ret;
2016 }
2017
2018 ////////////////////////////////////////////////////////////////////////////////
2019 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_DeInit()
2020 /// @brief \b Function \b Description: This routine is the deletion of Mutex for Audio module.
2021 /// @param <IN> \b NONE :
2022 /// @param <OUT> \b NONE :
2023 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
2024 /// @param <GLOBAL> \b NONE :
2025 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_DeInit(void)2026 MS_BOOL HAL_AUDIO_Mutex_DeInit(void)
2027 {
2028 MS_BOOL ret = TRUE;
2029
2030 if ((_s32AUDIOMutex == -1) &&
2031 (_s32AUDIOMutexReboot == -1) &&
2032 (_s32MutexLoadCode == -1) &&
2033 (_s32AUDIOMutexIDMA == -1))
2034 {
2035 return ret;
2036 }
2037
2038 if (_s32AUDIOMutex != -1)
2039 {
2040 if (OS_DELETE_MUTEX(_s32AUDIOMutex) != TRUE)
2041 {
2042 HALAUDIO_ERROR("Error! Delete Mutex failed!\n");
2043 ret = FALSE;
2044 }
2045 _s32AUDIOMutex = -1;
2046 }
2047
2048 if (_s32AUDIOMutexReboot != -1)
2049 {
2050 if (OS_DELETE_MUTEX(_s32AUDIOMutexReboot) != TRUE)
2051 {
2052 HALAUDIO_ERROR("Error! Delete Mutex for Reboot failed!\n");
2053 ret = FALSE;
2054 }
2055 _s32AUDIOMutexReboot = -1;
2056 }
2057
2058 if (_s32MutexLoadCode != -1)
2059 {
2060 if (OS_DELETE_MUTEX(_s32MutexLoadCode) != TRUE)
2061 {
2062 HALAUDIO_ERROR("Error! Delete Mutex for Load DSP failed!\n");
2063 ret = FALSE;
2064 }
2065 _s32MutexLoadCode = -1;
2066 }
2067
2068 if (_s32AUDIOMutexIDMA != -1)
2069 {
2070 if (OS_DELETE_MUTEX(_s32AUDIOMutexIDMA) != TRUE)
2071 {
2072 HALAUDIO_ERROR("Error! Delete Mutex for IMDA failed!\n");
2073 ret = FALSE;
2074 }
2075 _s32AUDIOMutexIDMA = -1;
2076 }
2077
2078 return ret;
2079 }
2080
2081 ////////////////////////////////////////////////////////////////////////////////
2082 /// @brief \b Function \b Name: HAL_AUDIO_GetChipType() @@Cathy
2083 /// @brief \b Function \b Description: This routine is used to get the IC version for API.
2084 /// @param <IN> \b NONE :
2085 /// @param <OUT> \b NONE :
2086 /// @param <RET> \b AU_CHIP_TYPE :
2087 /// @param <GLOBAL> \b NONE :
2088 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetChipType(void)2089 AU_CHIP_TYPE HAL_AUDIO_GetChipType(void)
2090 {
2091 return AU_CHIP_MUNICH;
2092 }
2093
2094 ////////////////////////////////////////////////////////////////////////////////
2095 /// @brief \b Function \b Name: HAL_AUDIO_Set_MMIO_BASE() @@Cathy
2096 /// @brief \b Function \b Description: This routine is used to set MMIO base
2097 /// @param <IN> \b u32_MMIO_MapBase :
2098 /// @param <OUT> \b NONE :
2099 /// @param <RET> \b :
2100 /// @param <GLOBAL> \b NONE :
2101 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_MMIO_BASE(MS_U32 u32_MMIO_MapBase)2102 void HAL_AUDIO_Set_MMIO_BASE(MS_U32 u32_MMIO_MapBase)
2103 {
2104 _gMIO_MapBase = u32_MMIO_MapBase; // Get the absolute MMIO address
2105 }
2106
2107 //-------------------------------------------------------------------------------------------------
2108 // Global Functions
2109 //-------------------------------------------------------------------------------------------------
2110
2111 ////////////////////////////////////////////////////////////////////////////////
2112 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadByte @@Cathy
2113 /// @brief \b Function \b Description: read 1 Byte data
2114 /// @param <IN> \b u32RegAddr: register address
2115 /// @param <OUT> \b None :
2116 /// @param <RET> \b MS_U8 : 8-bit register value
2117 /// @param <GLOBAL> \b None :
2118 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)2119 MS_U8 HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)
2120 {
2121 return (_AU_AbsReadByte((u32RegAddr-0x100000)));
2122 }
2123
2124 ////////////////////////////////////////////////////////////////////////////////
2125 /// @brief \b Function \b Name: HAL_AUDIO_ReadByte @@Cathy
2126 /// @brief \b Function \b Description: read 1 Byte data
2127 /// @param <IN> \b u32RegAddr: register address
2128 /// @param <OUT> \b None :
2129 /// @param <RET> \b MS_U8 : 8-bit register value
2130 /// @param <GLOBAL> \b None :
2131 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)2132 MS_U8 HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)
2133 {
2134 return (_AU_AbsReadByte(u32RegAddr+0x010000)); // Add audio bank offset
2135 }
2136
2137
2138 ////////////////////////////////////////////////////////////////////////////////
2139 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadReg @@Cathy
2140 /// @brief \b Function \b Description: read 2 Byte data
2141 /// @param <IN> \b u32RegAddr: register address
2142 /// @param <OUT> \b None :
2143 /// @param <RET> \b MS_U16 : 16-bit register value
2144 /// @param <GLOBAL> \b None :
2145 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)2146 MS_U16 HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)
2147 {
2148 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2149 return _AU_AbsRead2Byte((u32RegAddr-0x100000)); // Add audio bank offset
2150 }
2151
2152 ////////////////////////////////////////////////////////////////////////////////
2153 /// @brief \b Function \b Name: HAL_AUDIO_ReadReg @@Cathy
2154 /// @brief \b Function \b Description: read 2 Byte data
2155 /// @param <IN> \b u32RegAddr: register address
2156 /// @param <OUT> \b None :
2157 /// @param <RET> \b MS_U16 : 16-bit register value
2158 /// @param <GLOBAL> \b None :
2159 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)2160 MS_U16 HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)
2161 {
2162 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2163 return (_AU_AbsRead2Byte(u32RegAddr+0x010000)); // Add audio bank offset
2164 }
2165
2166 ////////////////////////////////////////////////////////////////////////////////
2167 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteReg
2168 /// @brief \b Function \b Description: write 2 Byte data
2169 /// @param <IN> \b u32RegAddr: register address
2170 /// @param <IN> \b u16Val : 2 byte data
2171 /// @param <OUT> \b None :
2172 /// @param <RET> \b None :
2173 /// @param <GLOBAL> \b None :
2174 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2175 void HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2176 {
2177 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2178 _AU_AbsWrite2Byte((u32RegAddr-0x100000),u16Val); // Add audio bank offset
2179 }
2180
2181 ////////////////////////////////////////////////////////////////////////////////
2182 /// @brief \b Function \b Name: HAL_AUDIO_WriteReg @@Cathy
2183 /// @brief \b Function \b Description: write 2 Byte data
2184 /// @param <IN> \b u32RegAddr: register address
2185 /// @param <IN> \b u16Val : 2 byte data
2186 /// @param <OUT> \b None :
2187 /// @param <RET> \b None :
2188 /// @param <GLOBAL> \b None :
2189 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2190 void HAL_AUDIO_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2191 {
2192 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2193 _AU_AbsWrite2Byte((u32RegAddr+0x010000),u16Val); // Add audio bank offset
2194 }
2195
2196 ////////////////////////////////////////////////////////////////////////////////
2197 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteByte
2198 /// @brief \b Function \b Description: write 1 Byte data
2199 /// @param <IN> \b u32RegAddr: register address
2200 /// @param <IN> \b u8Val : 1 byte data
2201 /// @param <OUT> \b None :
2202 /// @param <RET> \b None :
2203 /// @param <GLOBAL> \b None :
2204 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2205 void HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2206 {
2207 _AU_AbsWriteByte((u32RegAddr-0x100000), u8Val); // Add audio bank offset
2208 }
2209
2210 ////////////////////////////////////////////////////////////////////////////////
2211 /// @brief \b Function \b Name: HAL_AUDIO_WriteByte @@Cathy
2212 /// @brief \b Function \b Description: write 1 Byte data
2213 /// @param <IN> \b u32RegAddr: register address
2214 /// @param <IN> \b u8Val : 1 byte data
2215 /// @param <OUT> \b None :
2216 /// @param <RET> \b None :
2217 /// @param <GLOBAL> \b None :
2218 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2219 void HAL_AUDIO_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2220 {
2221 _AU_AbsWriteByte((u32RegAddr+0x010000), u8Val); // Add audio bank offset
2222 }
2223
2224 ////////////////////////////////////////////////////////////////////////////////
2225 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskByte @@Morris
2226 /// @brief \b Function \b Description: Mask write 8-bit data
2227 /// @param <IN> \b u32RegAddr: register address
2228 /// @param <IN> \b u16Val : 8-bit data
2229 /// @param <OUT> \b None :
2230 /// @param <RET> \b None :
2231 /// @param <GLOBAL> \b None :
2232 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2233 void HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2234 {
2235 _AU_AbsWriteMaskByte((u32RegAddr-0x100000), u8Mask, u8Val);
2236 }
2237
2238 ////////////////////////////////////////////////////////////////////////////////
2239 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskByte @@Cathy
2240 /// @brief \b Function \b Description: Mask write 8-bit data
2241 /// @param <IN> \b u32RegAddr: register address
2242 /// @param <IN> \b u16Val : 8-bit data
2243 /// @param <OUT> \b None :
2244 /// @param <RET> \b None :
2245 /// @param <GLOBAL> \b None :
2246 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2247 void HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2248 {
2249 _AU_AbsWriteMaskByte((u32RegAddr+0x010000), u8Mask, u8Val); // Add audio bank offset
2250 }
2251
2252 ////////////////////////////////////////////////////////////////////////////////
2253 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskReg
2254 /// @brief \b Function \b Description: Mask write 16-bit data
2255 /// @param <IN> \b u32RegAddr: register address
2256 /// @param <IN> \b u16Val : 16-bit data
2257 /// @param <OUT> \b None :
2258 /// @param <RET> \b None :
2259 /// @param <GLOBAL> \b None :
2260 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2261 void HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2262 {
2263 MS_U16 u16RegVal;
2264
2265 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2266 u16RegVal = _AU_AbsRead2Byte((u32RegAddr-0x100000));
2267 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2268 _AU_AbsWrite2Byte((u32RegAddr-0x100000), u16RegVal);
2269 }
2270
2271 ////////////////////////////////////////////////////////////////////////////////
2272 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskReg @@Cathy
2273 /// @brief \b Function \b Description: Mask write 16-bit data
2274 /// @param <IN> \b u32RegAddr: register address
2275 /// @param <IN> \b u16Val : 16-bit data
2276 /// @param <OUT> \b None :
2277 /// @param <RET> \b None :
2278 /// @param <GLOBAL> \b None :
2279 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2280 void HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2281 {
2282 MS_U16 u16RegVal;
2283
2284 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2285 u16RegVal = HAL_AUDIO_ReadReg(u32RegAddr);
2286 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2287 HAL_AUDIO_WriteReg(u32RegAddr, u16RegVal);
2288 }
2289
2290 ////////////////////////////////////////////////////////////////////////////////
2291 /// @brief \b Function \b Name: _HAL_AUDIO_Write4Byte @@Cathy
2292 /// @brief \b Function \b Description: write 4 Byte data
2293 /// @param <IN> \b u32RegAddr: register address
2294 /// @param <IN> \b u32Val : 4 byte data
2295 /// @param <OUT> \b None :
2296 /// @param <RET> \b None :
2297 /// @param <GLOBAL> \b None :
2298 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)2299 void _HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
2300 {
2301 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+0x010000] =(MS_U16) (u32Val&0xFFFF);
2302 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+2+0x010000] =(MS_U16) (u32Val>>16);
2303 }
2304
2305 ////////////////////////////////////////////////////////////////////////////////
2306 /// @brief \b Function \b Name: HAL_AUDIO_ReadMailBox() @@Need_Modify
2307 /// @brief \b Function \b Description: This routine is used to read the Dec or SE DSP mail box value
2308 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2309 /// @param <IN> \b u8ParamNum : Mail box address
2310 /// @param <OUT> \b NONE :
2311 /// @param <RET> \b U16 : Mail Box value
2312 /// @param <GLOBAL> \b NONE :
2313 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum)2314 MS_U16 HAL_AUDIO_ReadMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum)
2315 {
2316 MS_U16 u16Tmp1, u16Tmp2;
2317 MS_U32 i, u32MailReg;
2318
2319
2320 for (i=0; i<1000; i++)
2321 {
2322 if(bDspType==DSP_SE)
2323 {
2324 if(u8ParamNum<8)
2325 {
2326 u32MailReg = 0x2D70+(MS_U32)u8ParamNum * 2;
2327 }
2328 else
2329 {
2330 u32MailReg = REG_SE_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2331 }
2332 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2333 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2334 }
2335 else
2336 {
2337 if(u8ParamNum<8)
2338 {
2339 u32MailReg = 0x2D60+(MS_U32)u8ParamNum * 2;
2340 }
2341 else
2342 {
2343 u32MailReg = REG_DEC_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2344 }
2345 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2346 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2347 }
2348 if(u16Tmp1==u16Tmp2)
2349 {
2350 return u16Tmp1;
2351 }
2352 }
2353
2354 printf("Read Mailbox fail! \r\n");
2355 return 0;
2356
2357 }
2358
2359 ////////////////////////////////////////////////////////////////////////////////
2360 /// @brief \b Function \b Name: HAL_AUDIO_WriteDecMailBox() @@Need_Modify
2361 /// @brief \b Function \b Description: This routine is used to write Dec-DSP mail box
2362 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2363 /// @param <IN> \b u8ParamNum : Mail box address
2364 /// @param <IN> \b u16Data : value
2365 /// @param <OUT> \b NONE :
2366 /// @param <RET> \b NONE :
2367 /// @param <GLOBAL> \b NONE :
2368 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum,MS_U16 u16Data)2369 void HAL_AUDIO_WriteMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum, MS_U16 u16Data)
2370 {
2371 MS_U32 u32MailReg;
2372
2373 if(bDspType==DSP_SE)
2374 {
2375 u32MailReg = REG_SE_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2376 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2377 }
2378 else
2379 {
2380 u32MailReg = REG_DEC_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2381 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2382 }
2383 }
2384
2385
2386 ///-----------------------------------------------------------------------------
2387 ////////////////////////////////////////////////////////////////////////////////
2388 ////////////////////////////////////////////////////////////////////////////////
2389 ///
2390 /// AUDIO Initialize Relational Hal Function
2391 ///
2392 ////////////////////////////////////////////////////////////////////////////////
2393
2394 ////////////////////////////////////////////////////////////////////////////////
2395 ///-----------------------------------------------------------------------------
2396 ////////////////////////////////////////////////////////////////////////////////
2397 /// @brief \b Function \b Name: HAL_AUDIO_WriteInitTable() @@Cathy
2398 /// @brief \b Function \b Description: This function is used to write initial register table(8-bit mode)
2399 /// @param <IN> \b NONE :
2400 /// @param <OUT> \b NONE :
2401 /// @param <RET> \b NONE :
2402 /// @param <GLOBAL> \b NONE :
2403 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteInitTable(void)2404 void HAL_AUDIO_WriteInitTable(void)
2405 {
2406 MS_U16 i = 0;
2407 MS_U16 j = 0;
2408
2409 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2410 {
2411 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2412 {
2413 if(ResetDMIOTbl[j].u16Mask == 1)
2414 {
2415 if(ResetDMIOTbl[j].u16Value!=0)
2416 MsOS_DelayTask((MS_U32)(ResetDMIOTbl[j].u16Value));
2417 }
2418 }
2419 else
2420 {
2421 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2422 }
2423
2424 j++;
2425 }
2426
2427 while( !((AudioInitTbl[i].u32Addr == 0xFFFFFF) && (AudioInitTbl[i].u8Mask == 0)) )
2428 {
2429 if((AudioInitTbl[i].u32Addr == 0xFFFFFF))
2430 {
2431 if(AudioInitTbl[i].u8Mask == 1)
2432 {
2433 if(AudioInitTbl[i].u8Value!=0)
2434 MsOS_DelayTask((MS_U32)(AudioInitTbl[i].u8Value));
2435 }
2436 }
2437 else
2438 {
2439 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl[i].u32Addr, AudioInitTbl[i].u8Mask, AudioInitTbl[i].u8Value);
2440 }
2441
2442 i++;
2443 }
2444
2445 }
2446
2447 ////////////////////////////////////////////////////////////////////////////////
2448 /// @brief \b Function \b Name: HAL_AUDIO_WritePreInitTable()
2449 /// @brief \b Function \b Description: This function is used to set power on DAC sequence before setting init table.
2450 /// @param <IN> \b NONE :
2451 /// @param <OUT> \b NONE :
2452 /// @param <RET> \b NONE :
2453 /// @param <GLOBAL> \b NONE :
2454 ////////////////////////////////////////////////////////////////////////////////
2455 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_WritePreInitTable(void)2456 void HAL_AUDIO_WritePreInitTable(void)
2457 {
2458 MS_U16 i = 0;
2459
2460 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CODEC_CFG7+1) & 0x01) == 0x01) {
2461 printf("Audio has initialized, don't need to do Pre init again\n");
2462 return;
2463 }
2464
2465 while( !((AudioPreInitTbl_Clock_0[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock_0[i].u8Mask == 0)) )
2466 {
2467 if((AudioPreInitTbl_Clock_0[i].u32Addr == 0xFFFFFF))
2468 {
2469 if(AudioPreInitTbl_Clock_0[i].u8Mask == 1)
2470 {
2471 if(AudioPreInitTbl_Clock_0[i].u8Value!=0)
2472 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock_0[i].u8Value));
2473 }
2474 }
2475 else
2476 {
2477 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock_0[i].u32Addr, AudioPreInitTbl_Clock_0[i].u8Mask, AudioPreInitTbl_Clock_0[i].u8Value);
2478 }
2479 i++;
2480 }
2481
2482 i = 0;
2483 while( !((ResetDMIOTbl[i].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[i].u16Mask == 0)) )
2484 {
2485 if((ResetDMIOTbl[i].u32Addr == 0xFFFFFF))
2486 {
2487 if(ResetDMIOTbl[i].u16Mask == 1)
2488 {
2489 if(ResetDMIOTbl[i].u16Value!=0)
2490 MsOS_DelayTask((MS_U32)(ResetDMIOTbl[i].u16Value));
2491 }
2492 }
2493 else
2494 {
2495 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[i].u32Addr, ResetDMIOTbl[i].u16Mask, ResetDMIOTbl[i].u16Value);
2496 }
2497 i++;
2498 }
2499
2500 i = 0;
2501 while( !((AudioPreInitTbl_Clock_1[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock_1[i].u8Mask == 0)) )
2502 {
2503 if((AudioPreInitTbl_Clock_1[i].u32Addr == 0xFFFFFF))
2504 {
2505 if(AudioPreInitTbl_Clock_1[i].u8Mask == 1)
2506 {
2507 if(AudioPreInitTbl_Clock_1[i].u8Value!=0)
2508 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock_1[i].u8Value));
2509 }
2510 }
2511 else
2512 {
2513 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock_1[i].u32Addr, AudioPreInitTbl_Clock_1[i].u8Mask, AudioPreInitTbl_Clock_1[i].u8Value);
2514 }
2515 i++;
2516 }
2517
2518 }
2519
2520 ////////////////////////////////////////////////////////////////////////////////
2521 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2522 /// @brief \b Function \b Description: This function is used to enable earphone low power stage.
2523 /// @param <IN> \b NONE :
2524 /// @param <OUT> \b NONE :
2525 /// @param <RET> \b NONE :
2526 /// @param <GLOBAL> \b NONE :
2527 ////////////////////////////////////////////////////////////////////////////////
2528 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_LowPower_Stage(void)2529 void HAL_AUDIO_EnaEarphone_LowPower_Stage(void)
2530 {
2531 HAL_AUDIO_WriteMaskByte(0x2CEE, 0xFF, 0x03); // Disable BB by-pass
2532 #ifndef CONFIG_MBOOT
2533 HAL_AUDIO_WriteMaskByte(0x2CEF, 0xFF, 0x03); // Disable BB by-pass
2534 #endif
2535 HAL_AUDIO_WriteMaskByte(0x2CEC, 0xFF, 0x00); // Disable BB by-pass
2536 HAL_AUDIO_WriteMaskByte(0x2CED, 0xFF, 0x18); // Disable BB by-pass
2537 return;
2538 }
2539
2540 ////////////////////////////////////////////////////////////////////////////////
2541 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2542 /// @brief \b Function \b Description: This function is used to enable earphone high driving stage.
2543 /// @param <IN> \b NONE :
2544 /// @param <OUT> \b NONE :
2545 /// @param <RET> \b NONE :
2546 /// @param <GLOBAL> \b NONE :
2547 ////////////////////////////////////////////////////////////////////////////////
2548 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)2549 void HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)
2550 {
2551 return;
2552 }
2553
2554 ////////////////////////////////////////////////////////////////////////////////
2555 /// @brief \b Function \b Name: HAL_AUDIO_SetPowerOn() @@Need_Modify
2556 /// @brief \b Function \b Description: This routine is used to execute DSP power on/down setting.
2557 /// @param <IN> \b bPower_on : TRUE --power on
2558 /// FALSE--power off
2559 /// @param <OUT> \b NONE :
2560 /// @param <RET> \b NONE :
2561 /// @param <GLOBAL> \b NONE :
2562 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)2563 void HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)
2564 {
2565 DBG_AUDIO("HAL_AUDIO_SetPowerOn(%x)\r\n", bPower_on);
2566 if(bPower_on)
2567 {
2568 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x00); // DSP power up command, DO NOT touch bit3
2569 HAL_AUDIO_WriteMaskByte(0x2B42, 0xFF, 0x00); // Disable BB by-pass
2570 }
2571 else
2572 {
2573 HAL_AUDIO_DeInitialVars();
2574
2575 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x02); // DSP power down command
2576 AUDIO_DELAY1MS(100);
2577
2578 // Disable MIU Request for DEC-DSP
2579 HAL_MAD_Dis_MIUREQ();
2580
2581 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00); // SPDIF power down
2582 }
2583 }
2584
2585 ////////////////////////////////////////////////////////////////////////////////
2586 /// @brief \b Function \b Name: HAL_AUDIO_ADCInit() @@Cathy
2587 /// @brief \b Function \b Description: This routine is ADC relational register Init.
2588 /// @param <IN> \b NONE :
2589 /// @param <OUT> \b NONE :
2590 /// @param <RET> \b NONE :
2591 /// @param <GLOBAL> \b NONE :
2592 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ADCInit(void)2593 void HAL_AUDIO_ADCInit(void)
2594 {
2595 HAL_AUDIO_WriteMaskByte(0x2CDA, 0x03, 0x00); // power on ADC0 & ADC1
2596 HAL_AUDIO_WriteMaskByte(0x2CEE, 0x03, 0x03); //enable ADC dither
2597 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00); // power on ADC PGA
2598 HAL_AUDIO_WriteMaskByte(0x2CE5, 0xFC, 0x00); //ADC0 & ADC1 PGAain=0dB
2599 }
2600
2601 ////////////////////////////////////////////////////////////////////////////////
2602 /// @brief \b Function \b Name: HAL_AUDIO_SwResetMAD() @@Cathy
2603 /// @brief \b Function \b Description: This function is used to software reset MAD
2604 /// @param <IN> \b NONE :
2605 /// @param <OUT> \b NONE :
2606 /// @param <RET> \b NONE :
2607 /// @param <GLOBAL> \b NONE :
2608 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SwResetMAD(void)2609 void HAL_AUDIO_SwResetMAD(void)
2610 {
2611 MS_U16 j = 0;
2612
2613 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2614 {
2615 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2616 {
2617 if(ResetDMIOTbl[j].u16Mask == 1)
2618 {
2619 if(ResetDMIOTbl[j].u16Value!=0)
2620 AUDIO_DELAY1MS((MS_U32)(ResetDMIOTbl[j].u16Value));
2621 }
2622 }
2623 else
2624 {
2625 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2626 }
2627
2628 j++;
2629 }
2630
2631 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CODEC_CFG7+1) & 0x01) == 0x01) {
2632 printf("Audio has initialized, don't need to do SwReset again\n");
2633 return;
2634 }
2635
2636 /* Audio software engine reset */
2637 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0D);
2638 AUDIO_DELAY1MS(1);
2639 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0F);
2640 AUDIO_DELAY1MS(1);
2641 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x0D);
2642 AUDIO_DELAY1MS(1);
2643 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0x0F, 0x00);
2644 AUDIO_DELAY1MS(1);
2645 }
2646
2647 ////////////////////////////////////////////////////////////////////////////////
2648 /// @brief \b Function \b Name: HAL_AUDIO_ResetDSP() @@Cathy
2649 /// @brief \b Function \b Description: This function is used to reset DSP.
2650 /// @param <IN> \b NONE :
2651 /// @param <OUT> \b NONE :
2652 /// @param <RET> \b NONE :
2653 /// @param <GLOBAL> \b NONE :
2654 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ResetDSP(void)2655 void HAL_AUDIO_ResetDSP(void)
2656 {
2657 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x02); // Reset DSP
2658 AUDIO_DELAY1MS(2);
2659 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x03);
2660 }
2661
2662 ////////////////////////////////////////////////////////////////////////////////
2663 /// @brief \b Function \b Name: HAL_AUDIO_DecDspISR() @@Need_Modify
2664 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2665 /// @param <IN> \b NONE :
2666 /// @param <OUT> \b NONE :
2667 /// @param <RET> \b NONE :
2668 /// @param <GLOBAL> \b NONE :
2669 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecDspISR(void)2670 void HAL_AUDIO_DecDspISR(void) //Cathy need modify
2671 {
2672 //no event use this function now
2673 }
2674
2675 ////////////////////////////////////////////////////////////////////////////////
2676 /// @brief \b Function \b Name: HAL_AUDIO_SeDspISR() @@Need_Modify
2677 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2678 /// @param <IN> \b NONE :
2679 /// @param <OUT> \b NONE :
2680 /// @param <RET> \b NONE :
2681 /// @param <GLOBAL> \b NONE :
2682 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeDspISR(void)2683 void HAL_AUDIO_SeDspISR(void)
2684 {
2685 MS_U8 se_ISR_cmdType;
2686
2687 se_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_SE_ISRCMD);
2688
2689 /* add for PIP ASND Decode */
2690 if ( se_ISR_cmdType == 0x03 )
2691 {
2692 if (g_AudioVars2 != NULL)
2693 {
2694 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2695 }
2696 }
2697 }
2698
2699 ////////////////////////////////////////////////////////////////////////////////
2700 /// @brief \b Function \b Name: HAL_AUDIO_SetPlayFileFlag() @Cathy
2701 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2702 /// @param <IN> \b NONE :
2703 /// @param <OUT> \b NONE :
2704 /// @param <RET> \b NONE :
2705 /// @param <GLOBAL> \b NONE :
2706 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType,MS_BOOL bSet)2707 void HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType, MS_BOOL bSet)
2708 {
2709 HALAUDIO_CHECK_SHM_INIT;
2710
2711 if(bDspType == DSP_DEC)
2712 {
2713 g_AudioVars2->g_bDecPlayFileFlag = bSet;
2714 }
2715 else
2716 {
2717 g_AudioVars2->g_bSePlayFileFlag = bSet;
2718 }
2719 }
2720
2721 ////////////////////////////////////////////////////////////////////////////////
2722 /// @brief \b Function \b Name: HAL_AUDIO_GetPlayFileFlag() @@Cathy
2723 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2724 /// @param <IN> \b NONE :
2725 /// @param <OUT> \b NONE :
2726 /// @param <RET> \b NONE :
2727 /// @param <GLOBAL> \b NONE :
2728 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)2729 MS_BOOL HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)
2730 {
2731 MS_U32 es_rdPtr, es_wrPtr;
2732 MS_S32 es_level, es_bufSz, es_freeSpace;
2733 MS_U32 es_reqSize;
2734 MS_U8 r2_dec_id;
2735
2736 if(bDspType ==DSP_DEC)
2737 r2_dec_id = ADEC1;
2738 else if(bDspType ==DSP_SE)
2739 r2_dec_id = ADEC2;
2740 else
2741 r2_dec_id = ADEC1; //default case
2742
2743 es_rdPtr = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, r2_dec_id);
2744 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM( R2_SHM_PARAM_ES_WR_PTR, r2_dec_id, 0 );
2745 es_reqSize = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, r2_dec_id);
2746
2747 es_bufSz = ES1_DRAM_SIZE;
2748 es_level = es_wrPtr - es_rdPtr;
2749
2750 if (es_level < 0)
2751 es_level += es_bufSz;
2752
2753 es_freeSpace = es_bufSz - es_level;
2754
2755 if ( es_freeSpace > es_reqSize )
2756 return TRUE;
2757 else
2758 return FALSE;
2759 }
2760
2761 ////////////////////////////////////////////////////////////////////////////////
2762 /// @brief \b Function \b Name: HAL_AUDIO_SetEncodeDoneFlag() @@Cathy
2763 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2764 /// @param <IN> \b NONE :
2765 /// @param <OUT> \b NONE :
2766 /// @param <RET> \b NONE :
2767 /// @param <GLOBAL> \b NONE :
2768 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)2769 void HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)
2770 {
2771 if(bSet)
2772 g_bEncodeDoneFlag= 1;
2773 else
2774 g_bEncodeDoneFlag = 0;
2775 }
2776
2777 ////////////////////////////////////////////////////////////////////////////////
2778 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeDoneFlag() @@Cathy
2779 /// @brief \b Function \b Description: This function is used to get the Encoder flag status
2780 /// @param <IN> \b NONE :
2781 /// @param <OUT> \b NONE :
2782 /// @param <RET> \b NONE :
2783 /// @param <GLOBAL> \b NONE :
2784 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeDoneFlag(void)2785 MS_BOOL HAL_AUDIO_GetEncodeDoneFlag(void)
2786 {
2787 return g_bEncodeDoneFlag;
2788 }
2789
2790 /////////////////////////////////////////////////////////////////////////////////
2791 /// ///
2792 /// AUDIO I/O Config Relational Hal Function ///
2793 /// ///
2794 ////////////////////////////////////////////////////////////////////////////////
2795
2796 ////////////////////////////////////////////////////////////////////////////////
2797 /// @brief \b Function \b Name: HAL_AUDIO_GetPathGroup()
2798 /// @brief \b Function \b Description: This routine is used to get Audio path group type .
2799 /// @param output \b : Audio output path-group type
2800 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPathGroup(void)2801 AUDIO_PATH_GROUP_TYPE HAL_AUDIO_GetPathGroup(void)
2802 {
2803 // AUDIO_PATH_GROUP_1 : U3, Janus
2804 // AUDIO_PATH_GROUP_2 : T3, U4, T8, T9, T12, T13, J2
2805 return(AUDIO_PATH_GROUP_2);
2806 }
2807
2808 ////////////////////////////////////////////////////////////////////////////////
2809 /// @brief \b Function \b Name: HAL_AUDIO_SetNormalPath() @@ No used in T3 @@VVV
2810 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input and Output.
2811 /// @param <IN> \b u8Path : Audio DSP channel
2812 /// @param <IN> \b input : Audio input type
2813 /// @param <IN> \b output : Audio output type
2814 /// @param <OUT> \b NONE :
2815 /// @param <RET> \b NONE :
2816 /// @param <GLOBAL> \b NONE :
2817 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path,AUDIO_INPUT_TYPE input,AUDIO_OUTPUT_TYPE output)2818 void HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path, AUDIO_INPUT_TYPE input, AUDIO_OUTPUT_TYPE output)
2819 {
2820 u8Path=u8Path;
2821 input=input;
2822 output=output;
2823 }
2824
2825 ////////////////////////////////////////////////////////////////////////////////
2826 /// @brief \b Function \b Name: HAL_AUDIO_SetInputPath() @@VVV
2827 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input .
2828 /// @param <IN> \b input : Audio input type
2829 /// @param <IN> \b u8Path : Audio DSP channel
2830 /// @param <OUT> \b NONE :
2831 /// @param <RET> \b NONE :
2832 /// @param <GLOBAL> \b NONE :
2833 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input,AUDIO_PATH_TYPE u8Path)2834 void HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input , AUDIO_PATH_TYPE u8Path)
2835 {
2836 MS_U32 u32path_reg;
2837 MS_U8 u8input_src, u8input_idx, u8temp, path;
2838 AUDIO_INPUT_TYPE input1; // define this in order to do more check for ATV input source.
2839 input1 = input;
2840
2841 if((input == AUDIO_NULL_INPUT) || (u8Path ==AUDIO_PATH_NULL))
2842 {
2843 return;
2844 }
2845
2846 u8input_src = LONIBBLE(input);
2847 u8input_idx = HINIBBLE(input);
2848
2849 if (u8input_idx == 7) // if input source is ATV, change input depends on the definition of SIF_DSP_TYPE instead of the ATV input mux at boarddef
2850 {
2851 #if (SIF_DSP_TYPE == 0)
2852 input1 = AUDIO_DSP1_SIF_INPUT;
2853 #else
2854 input1 = AUDIO_DSP4_SIF_INPUT;
2855 #endif
2856 u8input_src = LONIBBLE(input1);
2857 }
2858
2859 if( u8Path == AUDIO_PATH_MAIN )
2860 {
2861 if (u8input_src == AUDIO_ADC_INPUT || u8input_src == AUDIO_ADC2_INPUT)
2862 {
2863 HAL_SOUND_EnableDcRemove(TRUE);
2864 }
2865 else
2866 {
2867 HAL_SOUND_EnableDcRemove(FALSE);
2868 }
2869 }
2870
2871 path=(MS_U8)u8Path;
2872
2873 /* save main speaker audio input */
2874 if( u8Path == AUDIO_PATH_MAIN )
2875 {
2876 g_audioSrcType = input1;
2877 }
2878 /* save sub channel audio input */
2879 else if( u8Path == AUDIO_PATH_6 )
2880 {
2881 g_audioSubSrcType = input1;
2882 }
2883
2884 if( path >= (sizeof(u32PathArray)/sizeof(u32PathArray[0])))
2885 {
2886 DBG_AUDIO(printf("DSP is not support more than CH8\n"));
2887 return;
2888 }
2889
2890 u32path_reg = u32PathArray[path];
2891
2892 // Set input
2893 switch(u8input_src)
2894 {
2895 case AUDIO_DSP1_INPUT:
2896 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x80);
2897 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG, 0x07,u8input_idx); // Set main parser source
2898 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx); // Set AD parser source
2899 break;
2900
2901 case AUDIO_DSP2_INPUT:
2902 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x81);
2903 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx);
2904 break;
2905
2906 case AUDIO_DSP3_INPUT:
2907 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x82);
2908 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x07,u8input_idx);
2909 break;
2910
2911 case AUDIO_DSP4_INPUT:
2912 /*
2913 * A patch here!
2914 * Just a temporary solution to hardcode channel 7 to 0x90 for HW DMA Reader2,
2915 */
2916 if(u8input_idx == 0x7)
2917 {
2918 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x83);
2919 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER4_CFG, 0x07,u8input_idx);
2920 }
2921 else
2922 {
2923 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x90);
2924 }
2925 break;
2926
2927 case AUDIO_ADC_INPUT:
2928 if(u8input_idx==0x0A)
2929 u8temp=0x40;
2930 else if(u8input_idx==0x0B)
2931 u8temp=0x50;
2932 else
2933 u8temp = (u8input_idx<<4);
2934 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x88);
2935 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, u8temp );
2936 break;
2937
2938 case AUDIO_ADC2_INPUT:
2939 if(u8input_idx==0x0A)
2940 u8temp=0x04;
2941 else if(u8input_idx==0x0B)
2942 u8temp=0x05;
2943 else
2944 u8temp = u8input_idx;
2945 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x89);
2946 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp );
2947 break;
2948
2949 case AUDIO_SPDIF_INPUT:
2950 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x86);
2951 break;
2952
2953 case AUDIO_I2S_INPUT:
2954 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x85);
2955 break;
2956
2957 case AUDIO_HDMI_INPUT:
2958 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x84);
2959 break;
2960
2961 case AUDIO_DMA_INPUT:
2962 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x8F);
2963 break;
2964
2965 default:
2966 break;
2967 }
2968 }
2969
2970 ////////////////////////////////////////////////////////////////////////////////
2971 /// @brief \b Function \b Name: HAL_AUDIO_SetOutputPath() @@Need_Modify
2972 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2973 /// @param <IN> \b u8Path : Audio DSP channel
2974 /// @param <IN> \b output : Audio output type
2975 /// @param <OUT> \b NONE :
2976 /// @param <RET> \b NONE :
2977 /// @param <GLOBAL> \b NONE :
2978 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2979 void HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2980 {
2981 u8Path=u8Path;
2982 u8Output=u8Output;
2983 }
2984
2985 ////////////////////////////////////////////////////////////////////////////////
2986 /// @brief \b Function \b Name: HAL_AUDIO_SetInternalPath() @@VVV
2987 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2988 /// @param <IN> \b u8Path : Audio internal path
2989 /// @param <IN> \b output : Audio output type
2990 /// @param <OUT> \b NONE :
2991 /// @param <RET> \b NONE :
2992 /// @param <GLOBAL> \b NONE :
2993 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2994 void HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2995 {
2996 MS_U8 path;
2997 // OUT0, OUT1, OUT2 , OUT3 , S/PDIF, I2S, HP , Dummy, Dummy, HDMI
2998 MS_U8 BalanceBitMap[10]={ 0, 1, 2, 3, 8, 4, 1, 7, 7, 10 };
2999
3000 if(u8Path >= INTERNAL_MAX_NUM)
3001 return;
3002
3003 path = (MS_U8)u8Path;
3004
3005 if(u8Path==INTERNAL_PCM_SE) // Only speaker use this path
3006 {
3007 g_BalanceMask=g_BalanceMask|(0x01<<BalanceBitMap[(int)u8Output]); // Enable balance mask
3008 }
3009
3010 if((HAL_AUDIO_ReadByte(M2S_MBOX_BALANCE_EN+1)&0x80)!=0)
3011 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
3012 else
3013 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000);// Balance disable
3014
3015 // Set output
3016 switch(u8Output)
3017 {
3018 case AUDIO_AUOUT0_OUTPUT:
3019 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0x0F, path);
3020 break;
3021
3022 case AUDIO_AUOUT1_OUTPUT:
3023 case AUDIO_HP_OUTPUT:
3024 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0xF0, (path<<4));
3025 break;
3026
3027 case AUDIO_AUOUT2_OUTPUT:
3028 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0x0F, path);
3029 break;
3030
3031 case AUDIO_AUOUT3_OUTPUT:
3032 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0xF0, (path<<4));
3033 break;
3034
3035 case AUDIO_I2S_OUTPUT:
3036 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0x0F, path);
3037 break;
3038
3039 case AUDIO_SPDIF_OUTPUT:
3040 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3+1, 0x0F, path); // Fix PCM in
3041 break;
3042
3043 case AUDIO_HDMI_OUTPUT:
3044 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3, 0x0F, path);
3045 break;
3046
3047 default:
3048 break;
3049 }
3050
3051 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_SPK_OutChannel, g_AudioVars2->AudioPathInfo.SpeakerOut, DSP_MEM_TYPE_PM); // INFO DSP SPK Output channel
3052 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_HP_OutChannel, g_AudioVars2->AudioPathInfo.HpOut, DSP_MEM_TYPE_PM); // INFO DSP HP Output channel
3053
3054 }
3055
3056
3057 ////////////////////////////////////////////////////////////////////////////////
3058 /// @brief \b Function \b Name: HAL_AUDIO_FwTriggerDSP() @@Need_Modify
3059 /// @brief \b Function \b Description: This routine send a PIO11 interrupt to DSP with a command on 0x2D34.
3060 /// @param <IN> \b cmd : 0xF0-- for MHEG5 file protocol
3061 /// @param <OUT> \b NONE :
3062 /// @param <RET> \b NONE :
3063 /// @param <GLOBAL> \b NONE :
3064 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd)3065 void HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd) //Cathy need modify
3066 {
3067 u16Cmd = u16Cmd;
3068 }
3069
3070 ////////////////////////////////////////////////////////////////////////////////
3071 /// @brief \b Function \b Name: HAL_AUDIO_DspBootOnDDR()
3072 /// @brief \b Function \b Description: Enable DSP load / reload code from DDR
3073 /// @param <IN> \b bEnable : 0 -- load code from FLASH
3074 /// 1 -- load code from DDR
3075 /// @param <OUT> \b NONE :
3076 /// @param <RET> \b NONE :
3077 /// @param <GLOBAL> \b NONE :
3078 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)3079 void HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)
3080 {
3081 g_bAudio_loadcode_from_dram = bEnable;
3082 }
3083
3084 ////////////////////////////////////////////////////////////////////////////////
3085 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3086 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3087 /// @param <IN> \b NONE :
3088 /// @param <OUT> \b NONE :
3089 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3090 /// @param <GLOBAL> \b NONE :
3091 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetIsDtvFlag(void)3092 MS_BOOL HAL_AUDIO_GetIsDtvFlag(void)
3093 {
3094 return g_bIsDTV;
3095 }
3096
3097 ////////////////////////////////////////////////////////////////////////////////
3098 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3099 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3100 /// @param <IN> \b NONE :
3101 /// @param <OUT> \b NONE :
3102 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3103 /// @param <GLOBAL> \b NONE :
3104 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)3105 void HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)
3106 {
3107 g_bIsDTV=bIsDTV;
3108 }
3109
3110 ////////////////////////////////////////////////////////////////////////////////
3111 /// @brief \b Function \b Name: HAL_AUDIO_Dec_Status() @@Cathy
3112 /// @brief \b Function \b Description: This routine is used to read the Decoder status.
3113 /// @param <IN> \b NONE :
3114 /// @param <OUT> \b NONE :
3115 /// @param <RET> \b MS_U8 : Decoder Status
3116 /// @param <GLOBAL> \b NONE :
3117 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Dec_Status(void)3118 MS_U8 HAL_AUDIO_Dec_Status(void)
3119 {
3120 return(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD));
3121 }
3122
3123 ////////////////////////////////////////////////////////////////////////////////
3124 /// @brief \b Function \b Name: HAL_AUDIO_Enc_Status() @@Kochien.Kuo
3125 /// @brief \b Function \b Description: This routine is used to read the Encoder status.
3126 /// @param <IN> \b NONE :
3127 /// @param <OUT> \b NONE :
3128 /// @param <RET> \b MS_U8 : Encoder Status
3129 /// @param <GLOBAL> \b NONE :
3130 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Enc_Status(void)3131 MS_U8 HAL_AUDIO_Enc_Status(void)
3132 {
3133 return(HAL_AUDIO_ReadByte(REG_DEC_ENCODE_CMD));
3134 }
3135
3136 ////////////////////////////////////////////////////////////////////////////////
3137 /// @brief \b Function \b Name: HAL_AUDIO_SE_Status() @@Cathy
3138 /// @brief \b Function \b Description: This routine is used to read the SE status.
3139 /// @param <IN> \b NONE :
3140 /// @param <OUT> \b NONE :
3141 /// @param <RET> \b MS_U8 : Decoder Status
3142 /// @param <GLOBAL> \b NONE :
3143 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Se_Status(void)3144 MS_U8 HAL_AUDIO_Se_Status(void)
3145 {
3146 return(HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD));
3147 }
3148
3149 ////////////////////////////////////////////////////////////////////////////////
3150 /// @brief \b Function \b Name: HAL_AUDIO_Set_Fading() @@Need_Modify
3151 /// @brief \b Function \b Description: This routine is used to set the Fading response time
3152 /// @param <IN> \b u32VolFading : Fading response time parameter
3153 /// @param <OUT> \b NONE :
3154 /// @param <RET> \b NONE :
3155 /// @param <GLOBAL> \b NONE :
3156 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)3157 void HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)
3158 {
3159 HAL_MAD2_Write_DSP_sram(0x114C, u32VolFading, DSP_MEM_TYPE_PM); //need touch
3160 }
3161
3162
3163 ////////////////////////////////////////////////////////////////////////////////
3164 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetUploadRate() @@Need_Modify
3165 /// @brief \b Function \b Description: According Blue tooth upload path, for different sampling rate setting the Synthesizer.
3166 /// @param <IN> \b bEnable : 0 -- Disable Blue Tooth upload
3167 /// 1 -- Enable Blue Tooth upload
3168 /// @param <IN> \b u8Samprate: Sampling Rate
3169 /// 0--no change
3170 /// 1--48KHz
3171 /// 2--44KHz
3172 /// 3--32KHz
3173 /// @param <OUT> \b NONE :
3174 /// @param <RET> \b NONE :
3175 /// @param <GLOBAL> \b NONE :
3176 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)3177 void HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)
3178 {
3179 u8Samprate &= 0x0003;
3180
3181 if(bEnable)
3182 {
3183 HAL_AUDIO_DecWriteByte(0x2C5A, 0x55);
3184 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0x10);
3185 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,u8Samprate);
3186 }
3187 else
3188 {
3189 HAL_AUDIO_DecWriteByte(0x2C5A, 0);
3190 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0);
3191 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,0);
3192 }
3193 }
3194
3195
3196 ////////////////////////////////////////////////////////////////////////////////
3197 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetBufferCounter() @@Need_Modify
3198 /// @brief \b Function \b Description: Set the DDR buffer according the sampling rate and the frame time
3199 /// @param <IN> \b u32Counter : if the sampling rate is 48KHz, the frame time is 40ms
3200 /// ==> the frame buffer size is 48000*0x04*2 (L/R) *2(Bytes/sample) = 0x1E00
3201 /// the counter is 0x1E00/8 = 960 (For 1*Burst DMA)
3202 /// @param <OUT> \b NONE :
3203 /// @param <RET> \b NONE :
3204 /// @param <GLOBAL> \b NONE :
3205 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)3206 void HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)
3207 {
3208 u32Counter &= 0x00FFFFFF;
3209 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_btFrameSize, u32Counter, DSP_MEM_TYPE_PM);
3210 }
3211
3212 ////////////////////////////////////////////////////////////////////////////////
3213 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_Enable() @@Need_Modify
3214 /// @brief \b Function \b Description: Enable/ Disable the path of USB PCM
3215 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
3216 /// @param <OUT> \b NONE :
3217 /// @param <RET> \b NONE :
3218 /// @param <GLOBAL> \b NONE :
3219 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)3220 void HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)
3221 {
3222 //this funcion is removed from DSP
3223 UNUSED(bEnable);
3224 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3225 }
3226
3227
3228 ////////////////////////////////////////////////////////////////////////////////
3229 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetFlag() @@Need_Modify
3230 /// @brief \b Function \b Description: Get interrupt flag for USBPCM function
3231 /// \b (Encoder path)
3232 /// @param <IN> \b NONE :
3233 /// @param <OUT> \b NONE :
3234 /// @param <RET> \b BOOL : interrupt flag
3235 /// @param <GLOBAL> \b NONE :
3236 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetFlag()3237 MS_BOOL HAL_AUDIO_USBPCM_GetFlag()
3238 {
3239 //this funcion is removed from DSP
3240 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3241 return 0;
3242 }
3243
3244 ////////////////////////////////////////////////////////////////////////////////
3245 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_SetFlag() @@Need_Modify
3246 /// @brief \b Function \b Description: clear interrupt flag for USBPCM function
3247 /// \b (Encoder path)
3248 /// @param <IN> \b bEnable : set false to clean interrupt flag
3249 /// @param <OUT> \b NONE :
3250 /// @param <RET> \b NONE :
3251 /// @param <GLOBAL> \b NONE :
3252 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)3253 void HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)
3254 {
3255 //this funcion is removed from DSP
3256 UNUSED(bEnable);
3257 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3258 }
3259
3260 ////////////////////////////////////////////////////////////////////////////////
3261 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetMemInfo() @@Need_Modify
3262 /// @brief \b Function \b Description: Get memory address and size for USBPCM function
3263 /// \b (Encoder path)
3264 /// @param <IN> \b NONE :
3265 /// @param <OUT> \b MS_U32 : address, size
3266 /// @param <RET> \b NONE :
3267 /// @param <GLOBAL> \b NONE :
3268 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO * uploadInfo)3269 void HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO *uploadInfo)
3270 {
3271 //this funcion is removed from DSP
3272 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3273 }
3274
3275 ////////////////////////////////////////////////////////////////////////////////
3276 /// @brief \b Function \b Name: HAL_AUDIO_ I2S_SetMode() @@Need_Modify
3277 /// @brief \b Function \b Description: This routine is used to Set the I2S output mode.
3278 /// @param <IN> \b Mode : MCLK , WORD_WIDTH , SOURCE_CH , FORMAT
3279 /// @param <IN> \b Value : Please reference the register table 0x2C8C & 0x2C8D .
3280 /// @param <OUT> \b NONE :
3281 /// @param <RET> \b NONE :
3282 /// @param <GLOBAL> \b NONE :
3283 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode,MS_U8 u8Val)3284 void _HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode, MS_U8 u8Val)
3285 {
3286 switch(u8Mode)
3287 {
3288 case AUDIO_I2S_MCLK: //0x2C8C[6:4]
3289 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x70,u8Val<<4);
3290 break;
3291
3292 case AUDIO_I2S_WORD_WIDTH: //0x2C8C[2:0]
3293 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x07,u8Val);
3294 break;
3295
3296 case AUDIO_I2S_FORMAT: //0x2C8C[3]
3297 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x08,u8Val<<3);
3298 break;
3299
3300 case AUDIO_I2S_SOURCE_CH:
3301 // No need ; Only select Group A in T3 .
3302 break;
3303
3304 case AUDIO_I2S_RXMODE:
3305 if(u8Val==I2S_SLAVE_MODE) //slave mode
3306 { //0x2C8C[2], 2CAE[13], 2CCE[15:13][1:0]
3307 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x00);
3308 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0x00);
3309 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0x20);
3310 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x00);
3311 }
3312 else //master mode
3313 {
3314 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x04);
3315 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0xA0);
3316 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0xC0);
3317 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x03);
3318 }
3319 break;
3320
3321 case AUDIO_I2S_TXMODE:
3322 // Tx always Master Mode;
3323 break;
3324
3325 default:
3326 break;
3327 }
3328 }
3329
3330
HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType,MS_BOOL bEnable)3331 static void HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType, MS_BOOL bEnable)
3332 {
3333 switch(eType)
3334 {
3335 case DD_DDCO:
3336 if(bEnable == TRUE)
3337 {
3338 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x1 );
3339 }
3340 else
3341 {
3342 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x0 );
3343 }
3344 break;
3345
3346 case DD_DDENCODE:
3347 if(bEnable == TRUE)
3348 {
3349 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x2 );
3350 }
3351 else
3352 {
3353 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x0 );
3354 }
3355 break;
3356
3357 case DTS_ENCODE_2CH:
3358 case DTS_ENCODE_MULTI:
3359 case MP3_ENCODE:
3360 default:
3361 HALAUDIO_ERROR("%s() - Choosen Encoder not exist\n",__FUNCTION__);
3362 break;
3363 }
3364 }
3365
HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DSP_ID eDspID)3366 static void HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DSP_ID eDspID)
3367 {
3368 switch (ePath)
3369 {
3370 case DIGITAL_SPDIF_OUTPUT:
3371 {
3372 switch(eDspID)
3373 {
3374 case AUDIO_DSP_ID_R2:
3375 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x4);
3376 break;
3377 case AUDIO_DSP_ID_SND:
3378 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x8);
3379 break;
3380 case AUDIO_DSP_ID_DEC:
3381 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x0);
3382 break;
3383 default:
3384 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3385 break;
3386 }
3387 }
3388 break;
3389
3390 case DIGITAL_HDMI_ARC_OUTPUT:
3391 {
3392 switch(eDspID)
3393 {
3394 case AUDIO_DSP_ID_R2:
3395 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3396 break;
3397 case AUDIO_DSP_ID_SND:
3398 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3399 break;
3400 case AUDIO_DSP_ID_DEC:
3401 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3402 break;
3403 default:
3404 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3405 break;
3406 }
3407 }
3408 break;
3409
3410 case DIGITAL_HDMI_OUTPUT:
3411 {
3412 switch(eDspID)
3413 {
3414 case AUDIO_DSP_ID_R2:
3415 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3416 break;
3417 case AUDIO_DSP_ID_SND:
3418 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3419 break;
3420 case AUDIO_DSP_ID_DEC:
3421 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3422 break;
3423 default:
3424 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3425 break;
3426 }
3427 }
3428 break;
3429
3430 default:
3431 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3432 break;
3433 }
3434
3435 }
3436
HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath,MS_BOOL bEnable)3437 static void HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath, MS_BOOL bEnable)
3438 {
3439
3440 switch(ePath)
3441 {
3442 case DIGITAL_SPDIF_OUTPUT:
3443 if(bEnable == TRUE)
3444 {
3445 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
3446 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
3447 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x2);
3448 }
3449 else
3450 {
3451 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select DSP1 */
3452 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
3453 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
3454 }
3455 break;
3456
3457 case DIGITAL_HDMI_ARC_OUTPUT:
3458 if(bEnable == TRUE)
3459 {
3460 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3461 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3462 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3463 }
3464 else
3465 {
3466 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3467 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3468 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3469 }
3470 break;
3471
3472 case DIGITAL_HDMI_OUTPUT:
3473 if(bEnable == TRUE)
3474 {
3475 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3476 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3477 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3478 }
3479 else
3480 {
3481 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3482 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3483 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3484 }
3485 break;
3486
3487 default:
3488 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3489 break;
3490 }
3491 }
3492 ////////////////////////////////////////////////////////////////////////////////
3493 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3494 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3495 /// @param <IN> \b u8Spdif_mode :
3496 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3497 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3498 /// bit[2] = 1: non-PCM NULL Payload
3499 /// @param <IN> \b u8Input_src 0 : DTV
3500 /// 1 : ATV
3501 /// 2 : HDMI
3502 /// 3 : ADC
3503 /// 4 : CardReader
3504 /// 5 : SPDIF
3505 /// @param <OUT> \b NONE :
3506 /// @param <RET> \b NONE :
3507 /// @param <GLOBAL> \b NONE :
3508 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSetting)3509 static void HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSetting)
3510 {
3511 Digital_Out_Channel_Status_t stDigitalChannelStatus;
3512 memset(&stDigitalChannelStatus, 0x00, sizeof(Digital_Out_Channel_Status_t));
3513
3514 if (ePath == DIGITAL_SPDIF_OUTPUT)
3515 {
3516 _HAL_AUDIO_SPDIF_SetMute(TRUE);
3517 }
3518 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3519 {
3520 //TODO: Mute HDMI , ARC
3521 }
3522 else if (ePath == DIGITAL_HDMI_OUTPUT)
3523 {
3524
3525 }
3526
3527 HAL_AUDIO_DigitalOut_GetChannelStatus(ePath, &stDigitalChannelStatus);
3528
3529 switch (stDigitalOutSetting->eDigitalOutfMode)
3530 {
3531 case DIGITAL_OUT_PCM:
3532 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, FALSE);
3533 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3534 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3535
3536 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
3537 break;
3538
3539 case DIGITAL_OUT_DOLBYDIGITAL:
3540 if (stDigitalOutSetting->u8R2NonPcmSetting == 0x01)
3541 {
3542 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3543 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, TRUE);
3544 }
3545 else if (stDigitalOutSetting->u8R2NonPcmSetting == 0x02)
3546 {
3547 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3548 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, TRUE);
3549 }
3550
3551 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3552 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3553 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3554 break;
3555
3556 case DIGITAL_OUT_DTS:
3557 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3558 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3559 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3560 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3561 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3562 break;
3563
3564 case DIGITAL_OUT_AAC_LC:
3565 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3566 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3567 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3568 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3569 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3570 break;
3571
3572 case DIGITAL_OUT_NONE:
3573 default:
3574 HALAUDIO_ERROR("%s() - Digital Mode %d not exist\n",__FUNCTION__,stDigitalOutSetting->eDigitalOutfMode);
3575 break;
3576 }
3577
3578 HAL_AUDIO_DigitalOut_SetChannelStatus(ePath, &stDigitalChannelStatus);
3579 // Restore Digital out mode
3580 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), &stDigitalOutSetting, sizeof(stDigitalOutSetting));
3581
3582 if (ePath == DIGITAL_SPDIF_OUTPUT)
3583 {
3584 if (g_AudioVars2->g_SPDIF_MuteStatus == FALSE)
3585 {
3586 _HAL_AUDIO_SPDIF_SetMute(FALSE);
3587 }
3588 }
3589 else
3590 {
3591 //TODO: um-Mute HDMI , ARC
3592 }
3593
3594 }
3595
3596
3597
3598 //static MS_BOOL HAL_AUDIO_DigitalOut_GetDataSource(AUDIO_OUTPORT_SOURCE_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE *retOutputType, AUDIO_DSP_ID *retNcmPath)
3599
HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSegtting)3600 static MS_BOOL HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSegtting)
3601 {
3602 AUDIO_DSP_CODE_TYPE SourceDspCodeType = AU_DVB_STANDARD_INVALID;
3603 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
3604 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
3605
3606 stDigitalOutSegtting->eSourceType = g_AudioVars2->eAudioSource;
3607 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3608 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3609
3610 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x , Source = %x, R2NonPcmSetting = %x\n\r", \
3611 __FUNCTION__, \
3612 stDigitalOutSegtting->eDigitalOutfMode, \
3613 stDigitalOutSegtting->u8NonPcmPath, \
3614 stDigitalOutSegtting->eSourceType, \
3615 stDigitalOutSegtting->u8R2NonPcmSetting);
3616
3617 switch (stDigitalOutSegtting->eDigitalOutfMode)
3618 {
3619 case DIGITAL_OUT_PCM:
3620 {
3621 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3622 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC;
3623 break;
3624 }
3625
3626 case DIGITAL_OUT_DOLBYDIGITAL:
3627 {
3628 switch (stDigitalOutSegtting->eSourceType)
3629 {
3630 case E_AUDIO_INFO_HDMI_IN:
3631 {
3632 if (bIsNonPCMInDec2)
3633 {
3634 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) &&
3635 (Dsp2CodeType == AU_DVB2_STANDARD_AC3P_AD))
3636 {
3637 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3638 }
3639 }
3640 else if ((Dsp1CodeType == AU_DVB_STANDARD_AC3) ||
3641 (Dsp1CodeType == AU_DVB_STANDARD_AC3P))
3642 {
3643 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3644 }
3645 break;
3646 }
3647
3648 case E_AUDIO_INFO_DTV_IN:
3649 case E_AUDIO_INFO_MM_IN:
3650 case E_AUDIO_INFO_GAME_IN:
3651 {
3652 SourceDspCodeType = Dsp1CodeType;
3653
3654 switch(SourceDspCodeType)
3655 {
3656 case AU_DVB_STANDARD_AAC:
3657 case AU_DVB_STANDARD_MS10_DDT:
3658 {
3659 if ((!MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_MS10_DDT)) &&
3660 (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DDE)))
3661 {
3662 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3663 }
3664 else
3665 {
3666 if ((HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1)&0xFFFF) < 32000)
3667 {
3668 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3669 }
3670 else
3671 {
3672 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_R2; /* R2 */
3673 stDigitalOutSegtting->u8R2NonPcmSetting = (SourceDspCodeType == AU_DVB_STANDARD_AAC) ? 0x01 : 0x02; /* DDCO : 0x2E95[0], DDEnc : 0x2E95[1] */
3674 }
3675 }
3676
3677 break;
3678 }
3679
3680 case AU_DVB_STANDARD_MS10_DDC:
3681 case AU_DVB_STANDARD_AC3:
3682 case AU_DVB_STANDARD_AC3P:
3683 {
3684 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3685 break;
3686 }
3687
3688 default:
3689 {
3690 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3691 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3692 break;
3693 }
3694
3695 }
3696
3697 break;
3698 }
3699
3700 case E_AUDIO_INFO_ATV_IN:
3701 case E_AUDIO_INFO_ADC_IN:
3702 case E_AUDIO_INFO_KTV_IN:
3703 default:
3704 {
3705 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3706 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3707 break;
3708 }
3709 }
3710 break;
3711 }
3712
3713 case DIGITAL_OUT_DTS:
3714 {
3715 switch (stDigitalOutSegtting->eSourceType)
3716 {
3717 case E_AUDIO_INFO_HDMI_IN:
3718 {
3719 if (bIsNonPCMInDec2)
3720 {
3721 if (Dsp2CodeType == AU_DVB2_STANDARD_DTS) // Need check
3722 {
3723 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3724 }
3725 }
3726 else if (Dsp1CodeType == AU_DVB_STANDARD_DTS)
3727 {
3728 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3729 }
3730 break;
3731 }
3732
3733 case E_AUDIO_INFO_MM_IN:
3734 case E_AUDIO_INFO_GAME_IN:
3735 {
3736 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_DTS;
3737 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3738 break;
3739 }
3740
3741 default:
3742 {
3743 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3744 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3745 break;
3746 }
3747 }
3748
3749 break;
3750 }
3751
3752 case DIGITAL_OUT_AAC_LC:
3753 {
3754 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3755 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3756 break;
3757 }
3758
3759 case DIGITAL_OUT_NONE:
3760 default:
3761 {
3762 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3763 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3764 break;
3765 }
3766
3767 }
3768
3769 return TRUE;
3770 }
3771
3772 ////////////////////////////////////////////////////////////////////////////////
3773 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3774 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3775 /// @param <IN> \b
3776 /// @param <IN> \b
3777 /// @param <OUT> \b NONE :
3778 /// @param <RET> \b NONE :
3779 /// @param <GLOBAL> \b NONE :
3780 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)3781 void HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)
3782 {
3783
3784 HALAUDIO_CHECK_SHM_INIT;
3785
3786 //TODO: add HDMI/ARC digital out status
3787
3788 // Set Digital mode to Digital out Status structure
3789 DigitalOutSetting_t stTempDigitalOutStatus;
3790 stTempDigitalOutStatus.eDigitalOutfMode = eDigitalMode;
3791 stTempDigitalOutStatus.eSourceType = E_AUDIO_INFO_DTV_IN; // Temp initial value
3792 stTempDigitalOutStatus.u8NonPcmPath = AUDIO_DSP_ID_ALL;
3793 stTempDigitalOutStatus.u8R2NonPcmSetting = 0x00;
3794 stTempDigitalOutStatus.eGroup = E_CONNECT_NULL;
3795
3796 if (ePath == DIGITAL_SPDIF_OUTPUT)
3797 {
3798 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.SpdifOut;
3799 }
3800 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3801 {
3802 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.ArcOut;
3803 }
3804
3805 //Determin Data Path
3806 HAL_AUDIO_DigitalOut_DetermineDataPath(ePath, &stTempDigitalOutStatus);
3807
3808 // if setting is difference to previous, set digital out mode
3809 if ((stTempDigitalOutStatus.eDigitalOutfMode != g_AudioVars2->stDigitalOutSetting[ePath].eDigitalOutfMode) ||
3810 (stTempDigitalOutStatus.eSourceType != g_AudioVars2->stDigitalOutSetting[ePath].eSourceType) ||
3811 (stTempDigitalOutStatus.u8NonPcmPath != g_AudioVars2->stDigitalOutSetting[ePath].u8NonPcmPath) ||
3812 (stTempDigitalOutStatus.u8R2NonPcmSetting != g_AudioVars2->stDigitalOutSetting[ePath].u8R2NonPcmSetting) ||
3813 (stTempDigitalOutStatus.eGroup != g_AudioVars2->stDigitalOutSetting[ePath].eGroup))
3814
3815 {
3816 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x\n\r", \
3817 __FUNCTION__, \
3818 stTempDigitalOutStatus.eDigitalOutfMode, \
3819 stTempDigitalOutStatus.u8NonPcmPath);
3820
3821 HAL_AUDIO_DigitalOut_SetDataPath(ePath, &stTempDigitalOutStatus);
3822 }
3823 }
3824
3825 ////////////////////////////////////////////////////////////////////////////////
3826 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3827 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3828 /// @param <IN> \b eType :
3829 /// @param <OUT> \b NONE :
3830 /// @param <RET> \b NONE :
3831 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3832 MS_BOOL HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3833 {
3834 MS_BOOL ret = FALSE;
3835
3836 HALAUDIO_CHECK_SHM_INIT;
3837
3838 switch (ePath)
3839 {
3840 case DIGITAL_SPDIF_OUTPUT:
3841 {
3842
3843 // Copy protection
3844 //C bit
3845 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3846 // L bit
3847 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3848
3849 // PCM format
3850 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3851 if(g_u32bDTSCD == 1)
3852 {
3853 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x40, 0x00);
3854 }
3855
3856 // Category
3857 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3858
3859 // Source number
3860 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3861
3862 // Channel number
3863 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3864
3865 // Sampling rate
3866 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3867
3868 // Clock precision
3869 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3870
3871 // Word Length
3872 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3873
3874 // Original sampling rate
3875 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3876
3877 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3878 {
3879 if(g_u32bDTSCD == 1)
3880 {
3881 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3882 }
3883 else
3884 {
3885 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x80);
3886 }
3887 }
3888 else
3889 {
3890 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3891 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3892 }
3893
3894 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00); //Tx1 Toggle bit[14]
3895 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x40);
3896 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00);
3897 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3898 break;
3899 }
3900
3901 case DIGITAL_HDMI_ARC_OUTPUT:
3902 {
3903 // Copy protection
3904 //C bit
3905 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3906 // L bit
3907 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3908
3909 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3910 if(g_u32bDTSCD == 1)
3911 {
3912 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x40, 0x00);
3913 }
3914
3915 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3916
3917 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3918
3919 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3920
3921 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3922
3923 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3924
3925 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3926
3927 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3928
3929 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3930 {
3931 if(g_u32bDTSCD == 1)
3932 {
3933 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3934 }
3935 else
3936 {
3937 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x80);
3938 }
3939 }
3940 else
3941 {
3942 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3943 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3944 }
3945 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3946 break;
3947 }
3948
3949 default:
3950 {
3951 HALAUDIO_ERROR("%s() - Invalid SPDIF Path\n",__FUNCTION__);
3952 break;
3953 }
3954 }
3955
3956 return ret;
3957 }
3958
3959 ////////////////////////////////////////////////////////////////////////////////
3960 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3961 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3962 /// @param <IN> \b eType :
3963 /// @param <OUT> \b NONE :
3964 /// @param <RET> \b NONE :
3965 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3966 MS_BOOL HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3967 {
3968 MS_BOOL ret = FALSE;
3969
3970 HALAUDIO_CHECK_SHM_INIT;
3971
3972 if (stChannelStatus == NULL)
3973 {
3974 HALAUDIO_ERROR("%s() : stChannelStatus shouldn't be NULL !!!\n", __FUNCTION__);
3975 }
3976 else
3977 {
3978 memcpy(stChannelStatus, &(g_AudioVars2->stDigitalOutChannelStatus[ePath]), sizeof(Digital_Out_Channel_Status_t));
3979 ret = TRUE;
3980 }
3981
3982 return ret;
3983 }
3984
3985 ///-----------------------------------------------------------------------------
3986 ////////////////////////////////////////////////////////////////////////////////
3987 ////////////////////////////////////////////////////////////////////////////////
3988 ///
3989 /// AUDIO SPDIF Relational Hal Function
3990 ///
3991 ////////////////////////////////////////////////////////////////////////////////
3992 ////////////////////////////////////////////////////////////////////////////////
3993 ///-----------------------------------------------------------------------------
3994 ////////////////////////////////////////////////////////////////////////////////
3995 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_HWEN() @@Cathy
3996 /// @brief \b Function \b Description: This routine is used to enable S/PDIF output (Hardware)
3997 /// @param <IN> \b bEnable: 0--Disable S/PDIF out
3998 /// 1--Enable S/PDIF out
3999 /// @param <OUT> \b NONE :
4000 /// @param <RET> \b NONE :
4001 /// @param <GLOBAL> \b NONE :
4002 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)4003 void _HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)
4004 {
4005 if(bEnable)
4006 {
4007 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x08, 0x00);
4008 }
4009 else
4010 {
4011 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x08, 0x08);
4012 }
4013 }
4014
4015 ////////////////////////////////////////////////////////////////////////////////
4016 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_SetMute() @@KH
4017 /// @brief \b Function \b Description: This routine is used to mute S/PDIF output(by DSP)
4018 /// @param <IN> \b bEnMute : 0--Disable mute
4019 /// 1--Enable mute
4020 /// @param <OUT> \b NONE :
4021 /// @param <RET> \b NONE :
4022 /// @param <GLOBAL> \b NONE :
4023 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)4024 void _HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)
4025 {
4026 MS_BOOL spdif_mute_status = FALSE;
4027 MS_U8 spdif_timecnt = 0;
4028
4029 HALAUDIO_CHECK_SHM_INIT;
4030
4031 /* check current status according to SPDIF Software mute bit */
4032 spdif_mute_status = (((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL) & 0x01) > 0) ? TRUE : FALSE);
4033
4034 /* apply change only when it's a different status from current status */
4035 if (spdif_mute_status != bEnMute)
4036 {
4037 if (bEnMute == TRUE)
4038 {
4039 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
4040 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x01); // Software mute
4041 }
4042 else
4043 {
4044 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x00); // Software unmute
4045 for (spdif_timecnt = 0; spdif_timecnt < 30; spdif_timecnt++)
4046 {
4047 AUDIO_DELAY1MS(1);
4048 }
4049 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
4050 }
4051 }
4052
4053 }
4054
4055 ////////////////////////////////////////////////////////////////////////////////
4056 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_ByPassChannel() @@Need_Modify
4057 /// @brief \b Function \b Description: ByPass the SPDIF channel (CH4)
4058 /// @param <IN> \b \b enable : TRUE --BYPASS CH4
4059 /// FALSE--OPEN CH4
4060 /// @param <OUT> \b NONE :
4061 /// @param <RET> \b NONE :
4062 /// @param <GLOBAL> \b NONE :
4063 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)4064 void _HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)
4065 {
4066 bEnable = bEnable;
4067 }
4068
4069 ////////////////////////////////////////////////////////////////////////////////
4070 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4071 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4072 /// @param <IN> \b u8Spdif_mode :
4073 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
4074 /// bit[1] = 0: PCM mode, 1: non-PCM mode
4075 /// bit[2] = 1: non-PCM NULL Payload
4076 /// @param <IN> \b u8Input_src 0 : DTV
4077 /// 1 : ATV
4078 /// 2 : HDMI
4079 /// 3 : ADC
4080 /// 4 : CardReader
4081 /// 5 : SPDIF
4082 /// @param <OUT> \b NONE :
4083 /// @param <RET> \b NONE :
4084 /// @param <GLOBAL> \b NONE :
4085 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode,MS_U8 u8Input_src)4086 void HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode, MS_U8 u8Input_src)
4087 {
4088 // Multiple npcm source, still need total rework
4089 AUDIO_SOURCE_INFO_TYPE eAudioSource = -1;
4090 MS_U8 u8SpdifMode = ((u8Spdif_mode == SPDIF_OUT_NONE) ? SPDIF_OUT_PCM : u8Spdif_mode);
4091 MS_U8 u8R2SpdifMode = ((u8SpdifMode == SPDIF_OUT_PCM) ? 1 : 2);
4092 MS_U8 u8MainDecodeId = 0;
4093 MS_U8 MainDspCodeType = AU_DVB_STANDARD_INVALID;
4094 MS_U8 Dsp1CodeType = AU_DVB_STANDARD_INVALID;
4095 MS_U8 Dsp2CodeType = AU_DVB_STANDARD_INVALID;
4096 MS_U32 u32bDTSCD = 0;
4097 MS_U32 u32DTSTranscodeFlag = 0;
4098 MS_U8 Digital_Out_DD_Support = 0;
4099 MS_U8 Digital_Out_DDP_Support = 0;
4100 MS_U8 Digital_Out_DTS_Support = 0;
4101 MS_U8 Digital_Out_AAC_Support = 0;
4102 MS_U32 u32HDMITxSamplingRate = 0;
4103 MS_U32 u32SPDIFTxSamplingRate = 0;
4104 MS_U64 u64DecSamplingRate = 0;
4105 static MS_U32 u32bPreDTSCD = 0xFF;
4106 static MS_U32 u32PreHDMITxSamplingRate = 0;
4107 static MS_U32 u32PreSPDIFTxSamplingRate = 0;
4108
4109 HALAUDIO_CHECK_SHM_INIT;
4110
4111 UNUSED(u8Input_src);
4112 eAudioSource = g_AudioVars2->eAudioSource;
4113 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
4114 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
4115 Digital_Out_DD_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DD].support_codec;
4116 Digital_Out_DDP_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DDP].support_codec;
4117 Digital_Out_DTS_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DTS].support_codec;
4118 Digital_Out_AAC_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_AAC].support_codec;
4119
4120 MainDspCodeType = Dsp1CodeType;
4121
4122 //HALAUDIO_ERROR("%s: u8Spdif_mode = %d, eAudioSource = %d, Dsp1CodeType = %d, Dsp2CodeType = %d, u8Input_src = %d\r\n", __FUNCTION__, u8Spdif_mode, eAudioSource, Dsp1CodeType, Dsp2CodeType, u8Input_src);
4123
4124 /* Configure SPDIF's Output Setting */
4125 switch(eAudioSource)
4126 {
4127 case E_AUDIO_INFO_DTV_IN:
4128 case E_AUDIO_INFO_MM_IN:
4129 case E_AUDIO_INFO_GAME_IN:
4130 {
4131 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
4132 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
4133 {
4134 MainDspCodeType = Dsp2CodeType;
4135
4136 u8MainDecodeId = 1; //DEC2
4137 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC2_sampleRate);
4138 }
4139 else
4140 {
4141 u8MainDecodeId = 0; //DEC1
4142 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_sampleRate);
4143 if (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_STOP)
4144 {
4145 u8SpdifMode = SPDIF_OUT_PCM;
4146 break;
4147 }
4148 }
4149
4150
4151 switch(MainDspCodeType)
4152 {
4153 case AU_DVB_STANDARD_AAC:
4154 case AU_DVB_STANDARD_MS10_DDT:
4155 {
4156 if (g_AudioVars2->DolbyEncFlag != 1)
4157 {
4158 u8SpdifMode = SPDIF_OUT_PCM;
4159 }
4160 #if (StereoAACOutputPCM)
4161 else if (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod) == AUD_CH_MODE_STEREO)
4162 {
4163 u8SpdifMode = SPDIF_OUT_PCM;
4164 }
4165 #endif
4166 else
4167 {
4168 if ((u8SpdifMode == SPDIF_OUT_NONPCM) ||
4169 (u8SpdifMode == SPDIF_OUT_TRANSCODE))
4170 {
4171 /* 0: default, 1: support, 2: not support */
4172 if (Digital_Out_DD_Support == 2)
4173 {
4174 u8SpdifMode = SPDIF_OUT_PCM;
4175 }
4176 else if ( u64DecSamplingRate < 4) //AAC SampleRate<16k
4177 {
4178 u8SpdifMode = SPDIF_OUT_PCM;
4179 }
4180 else
4181 {
4182 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 0, 0);
4183 }
4184 }
4185 else if (u8SpdifMode == SPDIF_OUT_BYPASS) // AAC Bypass
4186 {
4187 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 1, 0);
4188 }
4189 }
4190 break;
4191 }
4192
4193 case AU_DVB_STANDARD_AC3:
4194 case AU_DVB_STANDARD_AC3P:
4195 case AU_DVB_STANDARD_MS10_DDC:
4196 {
4197 /* 0: default, 1: support, 2: not support */
4198 if (Digital_Out_DD_Support == 2)
4199 {
4200 u8SpdifMode = SPDIF_OUT_PCM;
4201 }
4202 /* 0: default, 1: support, 2: not support */
4203 else if ((Digital_Out_DDP_Support == 1) && (u8SpdifMode != SPDIF_OUT_TRANSCODE))
4204 {
4205 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
4206 }
4207 else
4208 {
4209 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
4210 }
4211 break;
4212 }
4213
4214 case AU_DVB_STANDARD_DTS:
4215 case AU_DVB_STANDARD_DTSLBR:
4216 {
4217 /* 0: disable, 1: bypass/convert, 2: transcoder, 3: pcm */
4218 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
4219 if (u32DTSTranscodeFlag == 3)
4220 {
4221 u8SpdifMode = SPDIF_OUT_PCM;
4222 }
4223
4224 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) &&
4225 (u32DTSTranscodeFlag == 1))
4226 {
4227 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4228 }
4229
4230 /* 0: default, 1: support, 2: not support */
4231 if (Digital_Out_DTS_Support == 2)
4232 {
4233 u8SpdifMode = SPDIF_OUT_PCM;
4234 }
4235
4236 break;
4237 }
4238
4239 default:
4240 {
4241 u8SpdifMode = SPDIF_OUT_PCM;
4242 break;
4243 }
4244 }
4245
4246 break;
4247 }
4248
4249 case E_AUDIO_INFO_ATV_IN:
4250 case E_AUDIO_INFO_ADC_IN:
4251 case E_AUDIO_INFO_KTV_IN:
4252 {
4253 u8SpdifMode = SPDIF_OUT_PCM;
4254 break;
4255 }
4256
4257 case E_AUDIO_INFO_HDMI_IN:
4258 {
4259 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
4260 {
4261 MainDspCodeType = Dsp2CodeType;
4262 u8MainDecodeId = 1; //DEC2
4263 }
4264 else
4265 {
4266 u8MainDecodeId = 0; //DEC1
4267 }
4268
4269 if (HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE)
4270 {
4271 u8SpdifMode = SPDIF_OUT_PCM;
4272 }
4273 else
4274 {
4275 switch(MainDspCodeType)
4276 {
4277 case AU_DVB_STANDARD_AC3:
4278 case AU_DVB_STANDARD_AC3P:
4279 case AU_DVB_STANDARD_MS10_DDC:
4280 {
4281 /* 0: default, 1: support, 2: not support */
4282 if (Digital_Out_DD_Support == 2)
4283 {
4284 u8SpdifMode = SPDIF_OUT_PCM;
4285 }
4286 /* 0: default, 1: support, 2: not support */
4287 else if ((Digital_Out_DDP_Support == 1) && (u8SpdifMode != SPDIF_OUT_TRANSCODE))
4288 {
4289 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
4290 }
4291 else
4292 {
4293 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
4294 }
4295 break;
4296 }
4297
4298 case AU_DVB_STANDARD_DTS:
4299 {
4300 /* 0: disable, 1: bypass/convert, 2: transcoder, 3: pcm */
4301 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
4302 if (u32DTSTranscodeFlag == 3)
4303 {
4304 u8SpdifMode = SPDIF_OUT_PCM;
4305 }
4306
4307 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) &&
4308 (u32DTSTranscodeFlag == 1))
4309 {
4310 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4311 }
4312
4313 /* 0: default, 1: support, 2: not support */
4314 if (Digital_Out_DTS_Support == 2)
4315 {
4316 u8SpdifMode = SPDIF_OUT_PCM;
4317 }
4318 break;
4319 }
4320
4321 default:
4322 {
4323 u8SpdifMode = SPDIF_OUT_PCM;
4324 break;
4325 }
4326 }
4327 }
4328
4329 break;
4330 }
4331
4332 default:
4333 {
4334 HALAUDIO_ERROR("%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
4335 break;
4336 }
4337 }
4338
4339 //HALAUDIO_ERROR("%s: MainDspCodeType = %d, u8SpdifMode = %d\r\n", __FUNCTION__, MainDspCodeType, u8SpdifMode);
4340
4341 if(u8SpdifMode == SPDIF_OUT_PCM)
4342 {
4343 u32HDMITxSamplingRate = 48000;
4344 u32SPDIFTxSamplingRate = 48000;
4345 }
4346 else
4347 {
4348 u32HDMITxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, u8MainDecodeId);
4349 u32SPDIFTxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, u8MainDecodeId);
4350 }
4351
4352 if ((_HAL_AUDIO_SPDIF_GetMode() == u8SpdifMode) &&
4353 (g_AudioVars2->g_PreMainDecodeId == u8MainDecodeId) &&
4354 (g_AudioVars2->g_PreMainDspCodeType == MainDspCodeType) &&
4355 (u32PreHDMITxSamplingRate == u32HDMITxSamplingRate) &&
4356 (u32PreSPDIFTxSamplingRate == u32SPDIFTxSamplingRate))
4357 {
4358 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) ||
4359 (MainDspCodeType == AU_DVB_STANDARD_DTSLBR))
4360 {
4361 if (u32bPreDTSCD == u32bDTSCD)
4362 {
4363 /* In DTS/DTS-LBR case, if DTS-CD information is same, no need to to change SPDIF setting */
4364 return;
4365 }
4366 }
4367 else
4368 {
4369 /* No need to change SPDIF setting */
4370 return;
4371 }
4372 }
4373
4374 /* Change multi channel input source for DTS encode */
4375 if ((eAudioSource == E_AUDIO_INFO_HDMI_IN) && (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)))
4376 {
4377 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x02);
4378 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x02);
4379 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x02);
4380 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x02);
4381 }
4382 else
4383 {
4384 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x00);
4385 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x00);
4386 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x00);
4387 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x00);
4388 }
4389
4390 MS_BOOL retTx1, retTx2;
4391 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4392 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4393 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4394 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4395 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4396
4397 if (retTx1 == FALSE || retTx2 == FALSE)
4398 {
4399 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4400 return;
4401 }
4402
4403 /* Mute SPDIF before changing setting */
4404 _HAL_AUDIO_SPDIF_SetMute(TRUE);
4405
4406 /* Apply UI's SPDIF setting to Audio R2 */
4407 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC1, u8R2SpdifMode, 0);
4408 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC2, u8R2SpdifMode, 0);
4409
4410 HAL_AUR2_WriteByte(REG_R2_HDMI_NONPCM_PATH, u8MainDecodeId);
4411
4412 /* Apply SPDIF's Output Setting */
4413 switch (u8SpdifMode)
4414 {
4415 case SPDIF_OUT_NONPCM:
4416 case SPDIF_OUT_BYPASS:
4417 case SPDIF_OUT_TRANSCODE:
4418 {
4419 //HALAUDIO_PRINT("HAL SPDIF set as Non-PCM\n");
4420
4421 if (u8SpdifMode == SPDIF_OUT_TRANSCODE)
4422 {
4423 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, TRUE, 0);
4424 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, TRUE, 0);
4425 }
4426 else
4427 {
4428 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
4429 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
4430 }
4431
4432 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
4433 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
4434 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4435 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4436 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4437 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4438 AUDIO_DELAY1MS(5);
4439 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x02, 0x02); /* Non-PCM */
4440
4441 break;
4442 }
4443
4444 case SPDIF_OUT_PCM:
4445 default:
4446 {
4447 //HALAUDIO_PRINT("HAL SPDIF set as PCM\n");
4448
4449 AUDIO_DELAY1MS(5);
4450 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
4451 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
4452 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
4453 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
4454 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4455 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4456 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4457
4458 break;
4459 }
4460 }
4461
4462 u32bPreDTSCD = u32bDTSCD;
4463 g_u32bDTSCD = u32bDTSCD;
4464 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4465 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4466
4467 g_AudioVars2->g_eSpdifOutputType = u8SpdifMode;
4468 g_AudioVars2->g_PreMainDecodeId = u8MainDecodeId;
4469 g_AudioVars2->g_PreMainDspCodeType = MainDspCodeType;
4470
4471 u32PreHDMITxSamplingRate = u32HDMITxSamplingRate;
4472 u32PreSPDIFTxSamplingRate = u32SPDIFTxSamplingRate;
4473 HAL_AUDIO_Set_DecimationMode(AUDIO_HDMI_ARC_OUTPUT, u8MainDecodeId);
4474 HAL_AUDIO_Set_DecimationMode(AUDIO_SPDIF_OUTPUT, u8MainDecodeId);
4475
4476 _HAL_AUDIO_SPDIF_SetMute(g_AudioVars2->g_SPDIF_MuteStatus);
4477 }
4478
4479 ////////////////////////////////////////////////////////////////////////////////
4480 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_GetMode() @@KH
4481 /// @brief \b Function \b Description: This routine is used to get S/PDIF mode.
4482 /// @param <IN> \b NONE :
4483 /// @param <OUT> \b NONE :
4484 /// @param <RET> \b BYTE : Se-DSP REG_M2D_MAILBOX_SPDIF_CTRL value
4485 /// u8Spdif_mode = 0x0 : SPDIF enable, PCM mode
4486 /// u8Spdif_mode = 0x1 : SPDIF OFF
4487 /// u8Spdif_mode = 0x2 : SPDIF enable, non-PCM mode
4488 /// @param <GLOBAL> \b NONE :
4489 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_GetMode(void)4490 MS_U8 _HAL_AUDIO_SPDIF_GetMode(void)
4491 {
4492 return g_AudioVars2->g_eSpdifOutputType;
4493 }
4494
4495 ////////////////////////////////////////////////////////////////////////////////
4496 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetSCMS()
4497 /// @brief \b Function \b Description: This routine is used to set SPDIF SCMS.
4498 /// @param C_bit_en \b : copy right control bit, register in 0x2C80[5]
4499 /// @param L_bit_en \b : generation bit, register in 0x2C82[7]
4500 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en,MS_U8 L_bit_en)4501 void HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en, MS_U8 L_bit_en)
4502 {
4503 MS_BOOL retTx1, retTx2;
4504
4505 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4506 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4507 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4508 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4509 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4510
4511 if (retTx1 == TRUE && retTx2 == TRUE)
4512 {
4513 stDigitalChannelStatusTx1.stCopyRight.CBit = C_bit_en;
4514 stDigitalChannelStatusTx1.stCopyRight.LBit = L_bit_en;
4515 stDigitalChannelStatusTx2.stCopyRight.CBit = C_bit_en;
4516 stDigitalChannelStatusTx2.stCopyRight.LBit = L_bit_en;
4517 }
4518 else
4519 {
4520 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4521 return;
4522 }
4523
4524 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4525 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4526 }
4527
4528 ////////////////////////////////////////////////////////////////////////////////
4529 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_GetSCMS()
4530 /// @brief \b Function \b Description: This routine is used to get SPDIF SCMS.
4531 /// @return MS_U8 \b : SCMS[0] = C bit status, SCMS[1] = L bit status
4532 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_GetSCMS(void)4533 MS_U8 HAL_AUDIO_SPDIF_GetSCMS(void)
4534 {
4535
4536 MS_U8 SCMS_status, SCMS_C_bit_tmp, SCMS_L_bit_tmp;
4537
4538 HALAUDIO_CHECK_SHM_INIT;
4539
4540 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.CBit)
4541 {
4542 SCMS_C_bit_tmp = 0x01;
4543 }
4544 else
4545 {
4546 SCMS_C_bit_tmp = 0x00;
4547 }
4548
4549 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.LBit)
4550 {
4551 SCMS_L_bit_tmp = 0x02;
4552 }
4553 else
4554 {
4555 SCMS_L_bit_tmp = 0x00;
4556 }
4557
4558 SCMS_status = SCMS_C_bit_tmp | SCMS_L_bit_tmp;
4559
4560 return(SCMS_status);
4561 }
4562
4563 ////////////////////////////////////////////////////////////////////////////////
4564 /// @brief \b Function \b Name: HAL_AUDIO_SetChannelStatus()
4565 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4566 /// @param <IN> \b eType :
4567 /// @param <OUT> \b NONE :
4568 /// @param <RET> \b NONE :
4569 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType,SPDIF_CS_MODE_VALUE eValue)4570 void HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType, SPDIF_CS_MODE_VALUE eValue)
4571 {
4572 MS_U8 u8Type;
4573
4574 u8Type=(MS_U8)eType;
4575
4576 MS_BOOL retTx1, retTx2;
4577 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4578 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4579 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4580 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4581 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4582
4583
4584 if (retTx1 == FALSE || retTx2 == FALSE)
4585 {
4586 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4587 return;
4588 }
4589
4590 switch(u8Type)
4591 {
4592 case SPDIF_CHANNEL_STATUS_FS:
4593 stDigitalChannelStatusTx1.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx1
4594 stDigitalChannelStatusTx2.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx2
4595 break;
4596 case SPDIF_CHANNEL_STATUS_CATEGORY:
4597 stDigitalChannelStatusTx1.u8Category = (MS_U8)eValue; // Tx1 By-pass L- bit
4598 stDigitalChannelStatusTx2.u8Category = (MS_U8)eValue; // Tx2 By-pass L- bit
4599 break;
4600 case SPDIF_CHANNEL_STATUS_PCM_FORMAT:
4601 stDigitalChannelStatusTx1.u8PcmFormatControl = (MS_U8)eValue; // Tx1 By-pass Copy right bit
4602 stDigitalChannelStatusTx2.u8PcmFormatControl = (MS_U8)eValue; // Tx2 By-pass Copy right bit
4603 break;
4604
4605 default :
4606 break;
4607 }
4608
4609 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4610 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4611 }
4612
4613 ////////////////////////////////////////////////////////////////////////////////
4614 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_ChannelStatus_CTRL()
4615 /// @brief \b Function \b Description: This routine is used to control SPDIF CS in detail.
4616 /// @return MS_U8 \b :
4617 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode,AUDIO_SPDIF_CS_TYPE_STATUS status)4618 MS_BOOL HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode, AUDIO_SPDIF_CS_TYPE_STATUS status)
4619 {
4620 MS_BOOL status_rtn = FALSE;
4621 MS_BOOL retTx1, retTx2;
4622
4623 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4624 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4625 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4626 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4627 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4628
4629 if (retTx1 == FALSE || retTx2 == FALSE)
4630 {
4631 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4632 return status_rtn;
4633 }
4634
4635 switch (cs_mode)
4636 {
4637 case SPDIF_CS_CategoryCode:
4638 switch(status)
4639 {
4640 case SPDIF_CS_Category_BroadCast:
4641 stDigitalChannelStatusTx1.u8Category = 0x20;
4642 stDigitalChannelStatusTx2.u8Category = 0x20;
4643 break;
4644
4645 case SPDIF_CS_Category_General:
4646 stDigitalChannelStatusTx1.u8Category = 0x00;
4647 stDigitalChannelStatusTx2.u8Category = 0x00;
4648 break;
4649
4650 case SPDIF_CS_Category_BroadCast_JP:
4651 stDigitalChannelStatusTx1.u8Category = 0x20;
4652 stDigitalChannelStatusTx2.u8Category = 0x20;
4653 break;
4654
4655 case SPDIF_CS_Category_BroadCast_EU:
4656 stDigitalChannelStatusTx1.u8Category = 0x30;
4657 stDigitalChannelStatusTx2.u8Category = 0x30;
4658 break;
4659
4660 case SPDIF_CS_Category_BroadCast_USA:
4661 stDigitalChannelStatusTx1.u8Category = 0x26;
4662 stDigitalChannelStatusTx2.u8Category = 0x26;
4663 break;
4664
4665 default :
4666 stDigitalChannelStatusTx1.u8Category = 0x00;
4667 stDigitalChannelStatusTx2.u8Category = 0x00;
4668 break;
4669 }
4670 status_rtn = TRUE;
4671 break;
4672
4673 case SPDIF_CS_CopyRight:
4674 if(status == SPDIF_CS_CopyRight_CP)
4675 {
4676 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4677 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4678 }
4679 if(status == SPDIF_CS_CopyRight_NonCP)
4680 {
4681 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4682 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4683 }
4684 status_rtn = TRUE;
4685 break;
4686
4687 case SPDIF_CS_SourceNumber:
4688 if(status == SPDIF_CS_SourceNumber_2)
4689 {
4690 stDigitalChannelStatusTx1.u8SourceNumber = 0x40;
4691 stDigitalChannelStatusTx2.u8SourceNumber = 0x40;
4692 }
4693 if(status == SPDIF_CS_SourceNumber_5)
4694 {
4695 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4696 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4697 }
4698 if(status == SPDIF_CS_SourceNumber_6)
4699 {
4700 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4701 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4702 }
4703 status_rtn = TRUE;
4704 break;
4705
4706 case SPDIF_CS_ChannelNumber:
4707 if(status == SPDIF_CS_ChannelNumber_A_Left)
4708 {
4709 stDigitalChannelStatusTx1.u8ChannelNumber = 0x08;
4710 stDigitalChannelStatusTx2.u8ChannelNumber = 0x08;
4711 }
4712 if(status == SPDIF_CS_ChannelNumber_B_Right)
4713 {
4714 stDigitalChannelStatusTx1.u8ChannelNumber = 0x04;
4715 stDigitalChannelStatusTx2.u8ChannelNumber = 0x04;
4716 }
4717 if(status == SPDIF_CS_ChannelNumber_C)
4718 {
4719 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0C;
4720 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0C;
4721 }
4722 if(status == SPDIF_CS_ChannelNumber_D)
4723 {
4724 stDigitalChannelStatusTx1.u8ChannelNumber = 0x02;
4725 stDigitalChannelStatusTx2.u8ChannelNumber = 0x02;
4726 }
4727 if(status == SPDIF_CS_ChannelNumber_E)
4728 {
4729 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0A;
4730 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0A;
4731 }
4732 if(status == SPDIF_CS_ChannelNumber_F)
4733 {
4734 stDigitalChannelStatusTx1.u8ChannelNumber = 0x06;
4735 stDigitalChannelStatusTx2.u8ChannelNumber = 0x06;
4736 }
4737 status_rtn = TRUE;
4738 break;
4739
4740 case SPDIF_CS_SmpFreq:
4741 switch (status)
4742 {
4743 case SPDIF_CS_SmpFreq_192:
4744 stDigitalChannelStatusTx1.u8SamplingRate = 0x70;
4745 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
4746 break;
4747
4748 case SPDIF_CS_SmpFreq_96:
4749 stDigitalChannelStatusTx1.u8SamplingRate = 0x50;
4750 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
4751 break;
4752
4753 case SPDIF_CS_SmpFreq_48:
4754 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
4755 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
4756 break;
4757
4758 case SPDIF_CS_SmpFreq_176:
4759 stDigitalChannelStatusTx1.u8SamplingRate = 0x30;
4760 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
4761 break;
4762
4763 case SPDIF_CS_SmpFreq_88:
4764 stDigitalChannelStatusTx1.u8SamplingRate = 0x10;
4765 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
4766 break;
4767
4768 case SPDIF_CS_SmpFreq_44:
4769 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4770 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4771 break;
4772
4773 case SPDIF_CS_SmpFreq_64:
4774 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4775 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4776 break;
4777
4778 case SPDIF_CS_SmpFreq_32:
4779 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
4780 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
4781 break;
4782
4783 default:
4784 status_rtn = FALSE;
4785 break;
4786 }
4787 status_rtn = TRUE;
4788 break;
4789
4790 case SPDIF_CS_ClockAcc:
4791 status_rtn = TRUE;
4792 break;
4793
4794 case SPDIF_ChannelAB:
4795 if (status == SPDIF_ChannelAB_Invalid_ON)
4796 {
4797 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx1 Invalid bit=high in non-PCM mode
4798 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx2 Invalid bit=high in non-PCM mode
4799 }
4800 if (status == SPDIF_ChannelAB_Invalid_OFF)
4801 {
4802 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx1 Invalid bit=low in PCM mode
4803 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx2 Invalid bit=low in PCM mode
4804 }
4805 status_rtn = TRUE;
4806 break;
4807
4808 case SPDIF_CS_CopyProtect:
4809 switch (status)
4810 {
4811 case SPDIF_CS_CopyProtect_CopyFree:
4812 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4813 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4814 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4815 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4816 status_rtn = TRUE;
4817 break;
4818
4819 case SPDIF_CS_CopyProtect_CopyOnce:
4820 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4821 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4822 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4823 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4824 status_rtn = TRUE;
4825 break;
4826
4827 case SPDIF_CS_CopyProtect_CopyNever:
4828 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4829 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
4830 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4831 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
4832 status_rtn = TRUE;
4833 break;
4834
4835 default:
4836 status_rtn = FALSE;
4837 break;
4838 }
4839 break;
4840
4841 default:
4842 status_rtn = FALSE;
4843 break;
4844
4845 }
4846
4847 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4848 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4849
4850 return(status_rtn);
4851 }
4852
4853 ////////////////////////////////////////////////////////////////////////////////
4854 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_Monitor_SamplingRate()
4855 /// @brief \b Function \b Description: This routine is to set ADC clock for SPDIF raw out
4856 /// @param <IN> \b NONE :
4857 /// @param <OUT> \b NONE :
4858 /// @param <RET> \b NONE :
4859 /// @param <GLOBAL> \b NONE :
4860 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)4861 void HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)
4862 {
4863 return;
4864 }
4865
4866 ////////////////////////////////////////////////////////////////////////////////
4867 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetOutputType()
4868 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4869 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource,AUDIO_SPDIF_OUTPUT_TYPE eType)4870 void HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource, AUDIO_SPDIF_OUTPUT_TYPE eType)
4871 {
4872 eSource=eSource;
4873 eType=eType;
4874 }
4875
4876 ///-----------------------------------------------------------------------------
4877 ////////////////////////////////////////////////////////////////////////////////
4878 ////////////////////////////////////////////////////////////////////////////////
4879 ///
4880 /// AUDIO HDMI Relational Hal Function
4881 ///
4882 ////////////////////////////////////////////////////////////////////////////////
4883 ////////////////////////////////////////////////////////////////////////////////
4884 ///-----------------------------------------------------------------------------
4885 ////////////////////////////////////////////////////////////////////////////////
4886 /// @brief \b Function \b Name: _HAL_AUDIO_HDMI_Tx_SetMute()
4887 /// @brief \b Function \b Description: This routine is used to mute HDMI Tx output(by DSP)
4888 /// @param <IN> \b bEnMute : 0--Disable mute
4889 /// 1--Enable mute
4890 /// @param <OUT> \b NONE :
4891 /// @param <RET> \b NONE :
4892 /// @param <GLOBAL> \b NONE :
4893 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)4894 void _HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)
4895 {
4896 return;
4897 }
4898
4899 ////////////////////////////////////////////////////////////////////////////////
4900 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor()
4901 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status
4902 /// @param <IN> \b NONE :
4903 /// @param <OUT> \b NONE :
4904 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4905 /// @param <GLOBAL> \b NONE :
4906 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor(void)4907 MS_BOOL HAL_AUDIO_HDMI_NonpcmMonitor(void)
4908 {
4909 HAL_AUDIO_AbsWriteMaskByte(0x1027C8, 0x02, 0x02); // Add audio bank offset
4910 if(((HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_INPUT) & 0xC0)==0x40)||(HAL_AUDIO_HDMI_NonpcmMonitor2() == 0x1))
4911 {
4912 return (TRUE);
4913 }
4914 else
4915 {
4916 return (FALSE);
4917 }
4918 }
4919
4920 ////////////////////////////////////////////////////////////////////////////////
4921 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor2()
4922 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status from DSP
4923 /// @param <IN> \b NONE :
4924 /// @param <OUT> \b NONE :
4925 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4926 /// @param <GLOBAL> \b NONE :
4927 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor2(void)4928 MS_U8 HAL_AUDIO_HDMI_NonpcmMonitor2(void)
4929 {
4930 MS_U32 HDMI_lock_status_tmp;
4931 HDMI_lock_status_tmp = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_hdmi_npcm_lock, DSP_MEM_TYPE_DM);
4932 if (HDMI_lock_status_tmp == 0x30)
4933 {
4934 return (1);
4935 }
4936 else
4937 {
4938 return (0);
4939 }
4940 }
4941
4942 ////////////////////////////////////////////////////////////////////////////////
4943 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_DolbyMonitor() @@Need_Modify
4944 /// @brief \b Function \b Description: Report HDMI non-PCM Dolby mod status
4945 /// @param <IN> \b NONE :
4946 /// @param <OUT> \b NONE :
4947 /// @param <RET> \b u8DolbyModeType :
4948 /// 0-- Other mode
4949 /// 1-- Dolby mode
4950 /// @param <GLOBAL> \b NONE :
4951 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_DolbyMonitor(void)4952 MS_U8 HAL_AUDIO_HDMI_DolbyMonitor(void)
4953 {
4954 return HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_HDMI_PC);
4955 }
4956
4957 ////////////////////////////////////////////////////////////////////////////////
4958 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_SetNonpcm() @@Need_Modify
4959 /// @brief \b Function \b Description: Set HDMI PCM/non-PCM Mode
4960 /// @param <IN> \b nonPCM_en :
4961 /// -- 0: PCM mode
4962 /// -- 1: non-PCM mode
4963 /// @param <OUT> \b NONE :
4964 /// @param <RET> \b NONE :
4965 /// @param <GLOBAL> \b NONE :
4966 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)4967 void HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)
4968 {
4969 //=======================================================
4970 Hdmi_Input_Path HDMI_INPUT_PATH ;
4971 MS_BOOL bIsNonPCM= FALSE;
4972 MS_U8 u8DecoderType = 0;
4973
4974 bIsNonPCM = (MS_BOOL)(nonPCM_en & HDMI_NonPCM_Mask); // Use bit 1 mask check PCM/nonPCM
4975 HDMI_INPUT_PATH = (Hdmi_Input_Path)(nonPCM_en & HDMI_Input_Path_Mask); // Use bit2 mask check main or sub in PIP
4976
4977 if (bIsNonPCM) //====== HDMI nonpcm mode =======
4978 {
4979 u8DecoderType = HAL_AUDIO_HDMI_DolbyMonitor();
4980
4981 switch(u8DecoderType)
4982 {
4983 case AU_HDMI_DTS_TYPE1:
4984 case AU_HDMI_DTS_TYPE2:
4985 case AU_HDMI_DTS_TYPE3:
4986 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4987 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_DTS);
4988 else
4989 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_DTS);
4990
4991 break;
4992 case AU_HDMI_AC3:
4993 case AU_HDMI_AC3P:
4994 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4995 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_AC3);
4996 else
4997 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_AC3);
4998
4999 break;
5000 };
5001
5002 // Audio Input path config
5003 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5004 {
5005 // HDMI in 2nd Decoder
5006 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5007 {
5008 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_6);
5009 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5010 }
5011 else
5012 {
5013 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_MAIN);
5014 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5015 }
5016 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP); // Stop
5017 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG,0x07,0x04);
5018 MsOS_DelayTask(10);
5019 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_PLAY); // PlaY
5020 }
5021 else // HDMI in 1st Decoder
5022 {
5023 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5024 {
5025 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_6);
5026 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5027 }
5028 else
5029 {
5030 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_MAIN);
5031 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5032 }
5033
5034 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP); // Stop
5035 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04);
5036 MsOS_DelayTask(10);
5037 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_PLAY); // Play
5038 }
5039
5040 //========= Set for S/PDIF out ===========
5041 HAL_AUDIO_SPDIF_SetMode(_HAL_AUDIO_SPDIF_GetMode(), E_AUDIO_INFO_HDMI_IN);
5042
5043 //Byte swap setting
5044 if (HAL_AUDIO_HDMI_DolbyMonitor() == AU_HDMI_AC3P)
5045 {
5046 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 1, 0);
5047 }
5048 else
5049 {
5050 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 0, 0);
5051 }
5052 }
5053 else //====== HDMI pcm mode =======
5054 {
5055 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5056 {
5057 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_6);
5058 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x19);
5059 }
5060 else
5061 {
5062 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_MAIN);
5063 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x19);
5064 }
5065
5066 HAL_AUDIO_SPDIF_SetMode(SPDIF_OUT_PCM, E_AUDIO_INFO_HDMI_IN);
5067 }
5068
5069 }
5070
5071 ////////////////////////////////////////////////////////////////////////////////
5072 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_AC3_PathCFG() @@Need_Modify
5073 /// @brief \b Function \b Description: Set DVB/HDMI AC3 path Control
5074 /// @param <IN> \b u8Ctrl :
5075 /// -- 0: DVB2_AD path
5076 /// -- 1: HDMI path
5077 /// @param <OUT> \b NONE :
5078 /// @param <RET> \b NONE :
5079 /// @param <GLOBAL> \b NONE :
5080 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)5081 void HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)
5082 {
5083 if (u8Ctrl == 1)
5084 { // HDMI
5085 /* use CH1 decode HDMI AC3 */
5086 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04); // HDMI_AC3 REG CFG
5087 }
5088 else
5089 { // DTV
5090 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x00); // DVB1 REG CFG
5091 }
5092 }
5093
5094
5095 ////////////////////////////////////////////////////////////////////////////////
5096 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Get_SYNTH_FREQ() @@Need_Modify
5097 /// @brief \b Function \b Description: Audio HDMI CTS-N synthesizer input signal detect.
5098 /// @param <IN> \b NONE :
5099 /// @param <OUT> \b MS_U16 : return freq. If no signal, return 0
5100 /// @param <RET> \b NONE :
5101 /// @param <GLOBAL> \b NONE :
5102 ////////////////////////////////////////////////////////////////////////////////
5103
HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)5104 MS_U16 HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)
5105 {
5106 MS_U16 freq;
5107
5108 freq = HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH) + 0x100 * HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH+1);
5109
5110 if(freq & 0x8000)
5111 return 0; //no signal
5112
5113 return freq;
5114 }
5115
5116 ////////////////////////////////////////////////////////////////////////////////
5117 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Set_DwonSample() @@Cathy
5118 /// @brief \b Function \b Description: set HDMI downsample rate
5119 /// @param <IN> \b MS_U8 : donwsample ratio ; no need in T3
5120 /// @param <OUT> \b NONE :
5121 /// @param <RET> \b NONE :
5122 /// @param <GLOBAL> \b NONE :
5123 ////////////////////////////////////////////////////////////////////////////////
5124
HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)5125 void HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)
5126 {
5127 ratio=ratio; // No need in T3
5128 }
5129
5130
5131 ////////////////////////////////////////////////////////////////////////////////
5132 /// @brief \b Function \b Name: HAL_AUDIO_HDMIAutoMute() @@Need_Modify
5133 /// @brief \b Function \b This routine sets the automute function of HDMI.
5134 /// @param <IN> \b MS_U8 : ch : 0~5
5135 /// value: register value
5136 /// @param <OUT> \b NONE :
5137 /// @param <RET> \b NONE :
5138 /// @param <GLOBAL> \b NONE :
5139 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMIAutoMute(MS_U8 ch,MS_U8 value)5140 void HAL_AUDIO_HDMIAutoMute(MS_U8 ch, MS_U8 value)
5141 {
5142 if(ch < 4)
5143 {
5144 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+(ch<<1),value);
5145 }
5146 else if(ch == 4)
5147 {
5148 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+1,value);
5149 }
5150 else if(ch == 5)
5151 {
5152 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL2+1,value);
5153 }
5154 }
5155
5156 ////////////////////////////////////////////////////////////////////////////////
5157 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Tx_GetStatus()
5158 /// @brief \b Function \b Description: This routine is used to get HDMI Tx status
5159 /// @param onOff \b : HDMI tx function is availible in this chip ?
5160 /// @param hdmi_SmpFreq \b : Audio current sample freq for tx
5161 /// @param outType \b : PCM mode or nonPCM mode
5162 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL * onOff,AUDIO_FS_TYPE * hdmi_SmpFreq,HDMI_TX_OUTPUT_TYPE * outType)5163 void HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL *onOff, AUDIO_FS_TYPE *hdmi_SmpFreq, HDMI_TX_OUTPUT_TYPE *outType )
5164 {
5165 *onOff = FALSE;
5166 *hdmi_SmpFreq = AUDIO_FS_UNSUPPORT;
5167 *outType = HDMI_OUT_PCM;
5168 }
5169
5170
5171
5172 ///-----------------------------------------------------------------------------
5173 ////////////////////////////////////////////////////////////////////////////////
5174 ////////////////////////////////////////////////////////////////////////////////
5175 ///
5176 /// AUDIO Internel Use Hal Function
5177 ///
5178 ////////////////////////////////////////////////////////////////////////////////
5179 ////////////////////////////////////////////////////////////////////////////////
5180 ///-----------------------------------------------------------------------------
5181
5182 ////////////////////////////////////////////////////////////////////////////////
5183 /// @brief \b Function \b Name: _HAL_AUDIO_InitStep1() @@Need_Modify
5184 /// @brief \b Function \b Description: This routine is the initialization for Audio module(Step1).
5185 /// @param <IN> \b NONE :
5186 /// @param <OUT> \b NONE :
5187 /// @param <RET> \b NONE :
5188 /// @param <GLOBAL> \b NONE :
5189 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_InitStep1(void)5190 void _HAL_AUDIO_InitStep1(void)
5191 {
5192 HAL_AUDIO_WriteInitTable();
5193 HAL_AUDIO_SetPowerOn(1);
5194 HAL_AUDIO_SwResetMAD();
5195
5196 // Cathy need remove
5197 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0002);
5198 AUDIO_DELAY1MS(2);
5199 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0003);
5200
5201 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0002);
5202 AUDIO_DELAY1MS(2);
5203 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0003);
5204 // Reset Audio MIU Request for DEC-DSP
5205 HAL_MAD_DisEn_MIUREQ();
5206
5207 }
5208
5209
5210 ////////////////////////////////////////////////////////////////////////////////
5211 /// @brief \b Function \b Name: HAL_AUDIO_SetDspBaseAddr()
5212 /// @brief \b Function \b Description: This function is used to set bin file base address in flash for Audio module.
5213 /// @param <IN> \b u8Index :
5214 /// @param <IN> \b Bin_Base_Address :
5215 /// @param <IN> \b Mad_Base_Buffer_Adr :
5216 /// @param <OUT> \b NONE :
5217 /// @param <RET> \b NONE :
5218 /// @param <GLOBAL> \b NONE :
5219 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index,MS_U32 u32Bin_Base_Address,MS_U32 u32Mad_Base_Buffer_Adr)5220 void HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index, MS_U32 u32Bin_Base_Address, MS_U32 u32Mad_Base_Buffer_Adr)
5221 {
5222 HALAUDIO_CHECK_SHM_INIT;
5223
5224 g_AudioVars2->g_DSPMadMIUBank[u8Index] = (MS_U8) (u32Mad_Base_Buffer_Adr & 0x0000000F);
5225 u32Mad_Base_Buffer_Adr &= 0xFFFFFFF0;
5226 printf ("In %s, line(%d), u8Index(0x%x), u32Bin_Base_Address(0x%x), u32Mad_Base_Buffer_Adr(0x%x)\r\n", __FUNCTION__, __LINE__, u8Index, u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
5227
5228 switch(u8Index)
5229 {
5230 case(DSP_ADV): //DSP_ADV=R2=2
5231 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = u32Bin_Base_Address; //R2 ADDR setting
5232 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = u32Mad_Base_Buffer_Adr;
5233 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5234 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5235 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5236
5237 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = u32Bin_Base_Address; //SE ADEC ADDR setting
5238 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = u32Mad_Base_Buffer_Adr + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
5239 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5240 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
5241 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
5242
5243 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = u32Bin_Base_Address; //Comm ADDR setting
5244 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
5245 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5246 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
5247 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
5248 break;
5249 default:
5250 u8Index = u8Index;
5251 break;
5252 }
5253
5254 #ifndef MSOS_TYPE_NUTTX
5255 AUDIO_TEE_INFO_SHM_CHECK_NULL;
5256 REE_TO_TEE_MBX_MSG_SET_PARAM(0, u8Index);
5257 REE_TO_TEE_MBX_MSG_SET_PARAM(1, (MS_U8)(u32Bin_Base_Address&0xFF));
5258 REE_TO_TEE_MBX_MSG_SET_PARAM(2, (MS_U8)((u32Bin_Base_Address>>8)&0xFF));
5259 REE_TO_TEE_MBX_MSG_SET_PARAM(3, (MS_U8)((u32Bin_Base_Address>>16)&0xFF));
5260 REE_TO_TEE_MBX_MSG_SET_PARAM(4, (MS_U8)((u32Bin_Base_Address>>24)&0xFF));
5261 REE_TO_TEE_MBX_MSG_SET_PARAM(5, (MS_U8)(u32Mad_Base_Buffer_Adr&0xFF));
5262 REE_TO_TEE_MBX_MSG_SET_PARAM(6, (MS_U8)((u32Mad_Base_Buffer_Adr>>8)&0xFF));
5263 REE_TO_TEE_MBX_MSG_SET_PARAM(7, (MS_U8)((u32Mad_Base_Buffer_Adr>>16)&0xFF));
5264 REE_TO_TEE_MBX_MSG_SET_PARAM(8, (MS_U8)((u32Mad_Base_Buffer_Adr>>24)&0xFF));
5265 REE_TO_TEE_MBX_MSG_SET_PARAM_COUNT(9);
5266 HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr | REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
5267 #endif
5268 HALAUDIO_PRINT ("%d DSPBinBaseAddress = 0x%x\n", u8Index, g_AudioVars2->g_DSPBinBaseAddress[u8Index]);
5269 HALAUDIO_PRINT ("%d DSPMadBaseBufferAdr = 0x%x\n", u8Index, g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index]);
5270 HALAUDIO_PRINT ("%d DSPMadMIUBank = %d\n", u8Index, g_AudioVars2->g_DSPMadMIUBank[u8Index]);
5271 }
5272
5273 ////////////////////////////////////////////////////////////////////////////////
5274 /// @brief \b Function \b Name: HAL_AUDIO_GetDspMadBaseAddr()
5275 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5276 /// @param <IN> \b u8Index :
5277 /// @param <OUT> \b NONE :
5278 /// @param <RET> \b MS_U32: return the MAD base address
5279 /// @param <GLOBAL> \b NONE :
5280 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)5281 MS_U32 HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)
5282 {
5283 HALAUDIO_CHECK_SHM_INIT;
5284
5285 if (u8Index == DSP_DEC) //for MM case, they will ask DEC-DSP base as ES1 base, here we use SE-DSP instead
5286 {
5287 return g_AudioVars2->g_DSPMadBaseBufferAdr[DSP_SE];
5288 }
5289 return g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5290 }
5291
5292 ////////////////////////////////////////////////////////////////////////////////
5293 /// @brief \b Function \b Name: HAL_AUDIO_GetDspBinBaseAddr()
5294 /// @brief \b Function \b Description: This function is used to get the Bin file base address.
5295 /// @param <IN> \b u8Index :
5296 /// @param <OUT> \b NONE :
5297 /// @param <RET> \b MS_U32: return the Bin file base address
5298 /// @param <GLOBAL> \b NONE :
5299 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)5300 MS_U32 HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)
5301 {
5302 HALAUDIO_CHECK_SHM_INIT;
5303
5304 return g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5305 }
5306
5307 ////////////////////////////////////////////////////////////////////////////////
5308 /// @brief \b Function \b Name: HAL_AUDIO_SetDspCodeType()
5309 /// @brief \b Function \b Description: This function is used to set the DSP code type.
5310 /// @param <IN> \b NONE :
5311 /// @param <OUT> \b NONE :
5312 /// @param <RET> \b AUDIO_DSP_CODE_TYPE: DSP code type.
5313 /// @param <GLOBAL> \b NONE :
5314 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5315 void HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5316 {
5317 HALAUDIO_CHECK_SHM_INIT;
5318
5319 if(bFlag == FALSE)
5320 {
5321 DBG_AUDIO_ERROR(printf(" [Audio] DSP1 Load code fail !!! SetDspCodeType Fail !!! \r\n"));
5322 return;
5323 }
5324
5325 g_AudioVars2->g_DspCodeType = dspCodeType;
5326 }
5327
5328 ////////////////////////////////////////////////////////////////////////////////
5329 /// @brief \b Function \b Name: HAL_AUDIO_GetDspCodeType()
5330 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5331 /// @param <IN> \b NONE :
5332 /// @param <OUT> \b NONE :
5333 /// @param <RET> \b MS_U8: DSP code type.
5334 /// @param <GLOBAL> \b NONE :
5335 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspCodeType(void)5336 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDspCodeType(void)
5337 {
5338 HALAUDIO_CHECK_SHM_INIT;
5339
5340 return g_AudioVars2->g_DspCodeType;
5341 }
5342
5343
5344 ////////////////////////////////////////////////////////////////////////////////
5345 /// @brief \b Function \b Name: HAL_AUDIO_SetDsp2CodeType() @@Cathy
5346 /// @brief \b Function \b Description: This function is used to set the DSP2 code type.
5347 /// @param <IN> \b NONE :
5348 /// @param <OUT> \b NONE :
5349 /// @param <RET> \b AUDIO_DSP_CODE_TYPE: DSP code type.
5350 /// @param <GLOBAL> \b NONE :
5351 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5352 void HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5353 {
5354 HALAUDIO_CHECK_SHM_INIT;
5355
5356 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5357 {
5358 return;
5359 }
5360
5361 if(bFlag == FALSE)
5362 {
5363 DBG_AUDIO_ERROR(printf(" [Audio] DSP2 Load code fail !!! SetDsp2CodeType Fail !!! \r\n"));
5364 return;
5365 }
5366
5367 g_AudioVars2->g_Dsp2CodeType = dspCodeType;
5368 }
5369
5370 ////////////////////////////////////////////////////////////////////////////////
5371 /// @brief \b Function \b Name: HAL_AUDIO_GetDsp2CodeType() @@Cathy
5372 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5373 /// @param <IN> \b NONE :
5374 /// @param <OUT> \b NONE :
5375 /// @param <RET> \b AUDIO_DSP_CODE_TYPE: DSP code type.
5376 /// @param <GLOBAL> \b NONE :
5377 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDsp2CodeType(void)5378 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDsp2CodeType(void)
5379 {
5380 HALAUDIO_CHECK_SHM_INIT;
5381
5382 return g_AudioVars2->g_Dsp2CodeType;
5383 }
5384
5385 ////////////////////////////////////////////////////////////////////////////////
5386 /// @brief \b Function \b Name: HAL_AUDIO_GetDSPalive()
5387 /// @brief \b Function \b Description: This function is used to check if DSP alive.
5388 /// @param <IN> \b NONE :
5389 /// @param <OUT> \b NONE :
5390 /// @param <RET> \b MS_U8: DSP alive status.
5391 /// @param <GLOBAL> \b NONE :
5392 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDSPalive(void)5393 MS_U8 HAL_AUDIO_GetDSPalive(void)
5394 {
5395 HALAUDIO_CHECK_SHM_INIT;
5396
5397 return g_AudioVars2->g_u8DspAliveFlag;
5398 }
5399
5400 ////////////////////////////////////////////////////////////////////////////////
5401 /// @brief \b Function \b Name: HAL_AUDIO_SetDSPalive()
5402 /// @brief \b Function \b Description: This function is used to set flag after DSP alive.
5403 /// @param <IN> \b NONE :
5404 /// @param <OUT> \b NONE :
5405 /// @param <RET> \b NONE :
5406 /// @param <GLOBAL> \b NONE :
5407 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDSPalive(MS_U8 alive)5408 void HAL_AUDIO_SetDSPalive(MS_U8 alive)
5409 {
5410 HALAUDIO_CHECK_SHM_INIT;
5411
5412 g_AudioVars2->g_u8DspAliveFlag = alive;
5413 }
5414 ////////////////////////////////////////////////////////////////////////////////
5415 /// @brief \b Function \b Name: HAL_AUDIO_SetAdvSndEffDspCodeType() @@Cathy
5416 /// @brief \b Function \b Description: This function is used to set the DSP AdvSndEff code type.
5417 /// @param <IN> \b NONE :
5418 /// @param <OUT> \b NONE :
5419 /// @param <RET> \b AUDIO_DSP_CODE_TYPE: DSP code type.
5420 /// @param <GLOBAL> \b NONE :
5421 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5422 void HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5423 {
5424 HALAUDIO_CHECK_SHM_INIT;
5425
5426 if(bFlag == FALSE)
5427 {
5428 DBG_AUDIO_ERROR(printf(" [Audio] ADV_DSP Load code fail !!! SetAdvSndEffDspCodeType Fail !!! \r\n"));
5429 return;
5430 }
5431
5432 g_AudioVars2->g_AdvSndEffDspCodeType = dspCodeType;
5433 }
5434
5435 ////////////////////////////////////////////////////////////////////////////////
5436 /// @brief \b Function \b Name: HAL_AUDIO_GetAdvSndEffDspCodeType() @@Cathy
5437 /// @brief \b Function \b Description: This function is used to get the DSP AdvSndEff code type.
5438 /// @param <IN> \b NONE :
5439 /// @param <OUT> \b NONE :
5440 /// @param <RET> \b AUDIO_DSP_CODE_TYPE: DSP code type.
5441 /// @param <GLOBAL> \b NONE :
5442 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetAdvSndEffDspCodeType(void)5443 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetAdvSndEffDspCodeType(void)
5444 {
5445 HALAUDIO_CHECK_SHM_INIT;
5446
5447 return g_AudioVars2->g_AdvSndEffDspCodeType;
5448 }
5449
5450 ////////////////////////////////////////////////////////////////////////////////
5451 /// @brief \b Function \b Name: HAL_AUDIO_BackupMailbox() @@Need_Modify
5452 /// @brief \b Function \b Description: This function is used to backup SIF mailbox.
5453 /// @param <IN> \b NONE :
5454 /// @param <OUT> \b NONE :
5455 /// @param <RET> \b NONE :
5456 /// @param <GLOBAL> \b NONE :
5457 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BackupMailbox(void)5458 void HAL_AUDIO_BackupMailbox(void)
5459 {
5460 int i;
5461
5462 for(i=0;i<12;i++)
5463 {
5464 SIF_MailBoxArray[i]=HAL_AUDIO_ReadByte(REG_SE_M2D_MAIL_BOX_BASE+i);
5465 }
5466 }
5467
5468 ////////////////////////////////////////////////////////////////////////////////
5469 /// @brief \b Function \b Name: HAL_AUDIO_RestoreMailbox() @@Need_Modify
5470 /// @brief \b Function \b Description: This function is used to restore SIF mailbox.
5471 /// @param <IN> \b NONE :
5472 /// @param <OUT> \b NONE :
5473 /// @param <RET> \b NONE :
5474 /// @param <GLOBAL> \b NONE :
5475 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RestoreMailbox(void)5476 void HAL_AUDIO_RestoreMailbox(void)
5477 {
5478 int i;
5479
5480 for(i=0;i<12;i++)
5481 {
5482 HAL_AUDIO_WriteByte((REG_SE_M2D_MAIL_BOX_BASE+i), SIF_MailBoxArray[i]);
5483 }
5484 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0xFF); // Toggle 2BCE to update N.F value
5485 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0x00);
5486 }
5487
5488
5489 ////////////////////////////////////////////////////////////////////////////////
5490 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5491 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5492 /// @param <IN> \b eType : sampleRate of PCM
5493 /// @param <OUT> \b NONE :
5494 /// @param <RET> \b NONE :
5495 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)5496 void HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)
5497 {
5498 MS_U32 audio_pcm_dmaRdr_bufSz = HW_DMA_RDR1_BUF_SIZE;
5499 MS_U32 audio_pcm_dmaRdr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
5500 MS_U16 synthrate, divisor;
5501 unsigned char tmp1, tmp2, tmp3, tmp4;
5502 unsigned int i;
5503
5504 /* init DMA writer address */
5505 dma_writePtr = (unsigned char *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5506 dma_bufStartAddress = (unsigned char *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5507 dma_bufEndAddress = (unsigned char *) MS_PA2KSEG1(audio_pcm_dmaRdr_base + audio_pcm_dmaRdr_bufSz);
5508
5509 /* New DMA Reader setting
5510 * Formula is :
5511 * Synthesizer Rate = 216MHz / Divisor(1, 2, 4 or 8) * 1024 / 256 / Sampling Rate(32Khz, 44.1KHz or 48KHz)
5512 */
5513 switch(sampleRate)
5514 {
5515 case SAMPLE_RATE_96000:
5516 divisor = 0;
5517 synthrate = 0x2328;
5518 break;
5519 case SAMPLE_RATE_44100:
5520 divisor = 0;
5521 synthrate = 0x4C87;
5522 break;
5523 case SAMPLE_RATE_32000:
5524 divisor = 0;
5525 synthrate = 0x6978;
5526 break;
5527 case SAMPLE_RATE_48000:
5528 divisor = 0;
5529 synthrate = 0x4650;
5530 break;
5531 case SAMPLE_RATE_22050:
5532 divisor = 1;
5533 synthrate = 0x4C87;
5534 break;
5535 case SAMPLE_RATE_16000:
5536 divisor = 1;
5537 synthrate = 0x6978;
5538 break;
5539 case SAMPLE_RATE_24000:
5540 divisor = 1;
5541 synthrate = 0x4650;
5542 break;
5543 case SAMPLE_RATE_11025:
5544 divisor = 2;
5545 synthrate = 0x4C87;
5546 break;
5547 case SAMPLE_RATE_8000:
5548 divisor = 2;
5549 synthrate = 0x6978;
5550 break;
5551 case SAMPLE_RATE_12000:
5552 divisor = 2;
5553 synthrate = 0x4650;
5554 break;
5555 default:
5556 divisor = 0;
5557 synthrate = 0x4650;
5558 break;
5559 }
5560
5561 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
5562 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04); //SEL_CLK_DMA_READER
5563 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F ); //CH8 sel to DMA Rdr
5564
5565 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //reset dma reader
5566
5567 HAL_AUDIO_WriteMaskByte(0x2B8E, 0xFF, ((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE) & 0xFF)); //DMA Reader Base Addr[7:0]
5568 HAL_AUDIO_WriteMaskReg(0x2B84, 0xFFFF,(((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>8) & 0xFFFF)); //DMA Reader Base Addr[23:8]
5569 HAL_AUDIO_WriteMaskByte(0x2B8F, 0x0F, (((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>24) & 0x0F)); //DMA Reader Base Addr[27:24]
5570
5571 HAL_AUDIO_WriteMaskReg(0x2B86, 0xFFFF, audio_pcm_dmaRdr_bufSz/BYTES_IN_MIU_LINE); //setting : DMA Reader Size
5572 HAL_AUDIO_WriteMaskReg(0x2B88, 0xFFFF, audio_pcm_dmaRdr_bufSz - 12); //setting : DMA Reader Overrun Thr
5573 HAL_AUDIO_WriteMaskReg(0x2B8A, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
5574
5575 /* synthersizer setting update */ //DMA reader
5576 HAL_AUDIO_WriteMaskByte(0x2CA4, 0x20, 0x20); //enable DMA synthesizer
5577 HAL_AUDIO_WriteMaskReg(0x2CB0, 0x6000, (divisor << 13)); //Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH
5578 HAL_AUDIO_WriteMaskReg(0x2C20, 0xFFFF, synthrate); //DMA synthesizer N.F.
5579
5580 /* Reset and Start DMA Reader */
5581 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x6402);
5582 AUDIO_DELAY1MS(1);
5583 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x2402);
5584
5585 /* Clear DMA Reader buffer */
5586 for ( i = 0; i < (HW_DMA_RDR1_BUF_SIZE/4); i++ )
5587 {
5588 tmp1 = 0;
5589 tmp2 = 0;
5590 tmp3 = 0;
5591 tmp4 = 0;
5592
5593 *dma_writePtr++ = tmp1;
5594 *dma_writePtr++ = tmp2;
5595 *dma_writePtr++ = tmp3;
5596 *dma_writePtr++ = tmp4;
5597 }
5598
5599 /* Reset Write Pointer */
5600 dma_writePtr = dma_bufStartAddress;
5601 }
5602
5603 ////////////////////////////////////////////////////////////////////////////////
5604 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5605 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5606 /// @param <IN> \b eType : sampleRate of PCM
5607 /// @param <OUT> \b NONE :
5608 /// @param <RET> \b NONE :
5609 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_AllInput_Init(void)5610 void HAL_AUDIO_DmaReader_AllInput_Init(void)
5611 {
5612 HAL_AUDIO_DmaReader_Init(SAMPLE_RATE_48000);
5613 return;
5614 }
5615
5616 ////////////////////////////////////////////////////////////////////////////////
5617 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_WritePCM()
5618 /// @brief \b Function \b Description: This routine is used to write PCM data into DMA reader Buffer
5619 /// @param <IN> \b eType : buffer bytes
5620 /// @param <OUT> \b NONE : TRUE or FALSE
5621 /// @param <RET> \b NONE :
5622 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_WritePCM(void * buffer,MS_U32 bytes)5623 MS_BOOL HAL_AUDIO_DmaReader_WritePCM(void* buffer, MS_U32 bytes)
5624 {
5625 MS_U8 *bufptr = (MS_U8 *)MS_PA2KSEG1((MS_VIRT)buffer);
5626 MS_U8 tmp1, tmp2, tmp3, tmp4, replay_flag=0;
5627 MS_U32 i, level_cnt;
5628
5629 // Mask LEVEL_CNT_MASK before read
5630 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5631 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5632 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5633
5634 if ( level_cnt <= 6 )
5635 {
5636 if ((HAL_AUDIO_ReadReg(0x2B80) & 0x0001) == 0x0001)
5637 replay_flag = 1;
5638
5639 /* reset dma reader */
5640 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //clear wr cntrs
5641
5642 /* Reset and Start DMA Reader */
5643 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x6402);
5644 AUDIO_DELAY1MS(1);
5645 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x2402);
5646
5647 /* Reset Write Pointer */
5648 dma_writePtr = dma_bufStartAddress;
5649
5650 printf("***** Audio DMAReader Buffer empty !! ***** \r\n");
5651 }
5652
5653 // Mask LEVEL_CNT_MASK before read
5654 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5655 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5656 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5657 if(level_cnt < (HW_DMA_RDR1_BUF_SIZE - bytes*2)/BYTES_IN_MIU_LINE)
5658 {
5659 for ( i = 0; i < (bytes/2); i++ )
5660 {
5661 tmp1 = 0;
5662 tmp2 = *bufptr++;
5663 tmp3 = *bufptr++;
5664 tmp4 = 0;
5665
5666 *dma_writePtr++ = tmp1;
5667 *dma_writePtr++ = tmp2;
5668 *dma_writePtr++ = tmp3;
5669 *dma_writePtr++ = tmp4;
5670
5671 if ( dma_writePtr >= dma_bufEndAddress )
5672 dma_writePtr = dma_bufStartAddress;
5673 }
5674 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, bytes*2/BYTES_IN_MIU_LINE);
5675 AUDIO_DELAY1US(5); // To prevent slow update of level_cnt
5676
5677 if (replay_flag == 1)
5678 {
5679 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
5680 AUDIO_DELAY1MS(1);
5681 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
5682 }
5683 return TRUE;
5684 }
5685 return FALSE;
5686 }
5687
5688 ////////////////////////////////////////////////////////////////////////////////
5689 /// @brief \b Function \b Name: HAL_AUDIO_SetEntertainmentMode()
5690 /// @brief \b Function \b Description: This routine is used to switch the DTV/KTV/GAME mode
5691 /// @param <IN> \b eMode :
5692 /// @param <RET> \b NONE :
5693 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)5694 void HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)
5695 {
5696 switch((int)eMode)
5697 {
5698 case AUDIO_ETMODE_DTV :
5699 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5700 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x00);
5701 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5702 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x00); // ADC0 gain 0dB
5703 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5704 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5705 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5706 break;
5707
5708 case AUDIO_ETMODE_KTV :
5709 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5710 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5711 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x80); // enable KTV function
5712 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x80); // ADC0 gain 6dB
5713 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5714 HAL_AUDIO_WriteMaskReg(REG_SNDR2_ADVSND_SEL, 0xFF00, 0x1E00); // Switch R2 to KTV mode
5715 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
5716 break;
5717
5718 case AUDIO_ETMODE_KTV2 : // Use I2S input ; not MicroPhone in
5719 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5720 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5721 HAL_AUDIO_WriteMaskByte(0x2D47 , 0xF0, 0xA0); // enable KTV mode; Skyworth (stone) model
5722 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5723 HAL_AUDIO_WriteMaskByte(0x2D5D , 0x80, 0x80); // Mute MIC volume (only mix MP3 & PCM DMA data)
5724 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5725 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5726 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
5727 break;
5728
5729 case AUDIO_ETMODE_GAME :
5730 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5731 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5732 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5733 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5734 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5735 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5736 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5737 break;
5738
5739 case AUDIO_ETMODE_VOIP_ON:
5740 //Voip will setup snd system to GAME MODE,
5741 //In GAME MODE, Voip used 0x2D46[7:0] to
5742 //upload Raw_Delay_SE to DRAM.
5743 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0xA1);
5744
5745 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5746 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xE0);
5747 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0xC4);
5748
5749 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5750 AUDIO_DELAY1MS(1);
5751 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5752 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5753
5754 #if 0
5755 //config SRC to 8KHz
5756 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xF0);//0xE0}, // Group A SRC rate
5757 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x03);//0x07},
5758 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0xF0);//0x50},
5759 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0xD2);//0x46},
5760 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5761 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x04);//0x08},
5762 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0xF0);//0x50},
5763 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0xD2);//0x46},
5764 //update SYNTH
5765 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5766 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5767 AUDIO_DELAY1MS(1);
5768 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5769 //reset GroupA SRC
5770 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5771 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5772 AUDIO_DELAY1MS(1);
5773 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5774 #endif
5775
5776 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_ON\r\n");
5777 break;
5778
5779 case AUDIO_ETMODE_VOIP_OFF:
5780 //disable upload Raw_Delay_SE to DRAM.
5781 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0x00);
5782
5783 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5784 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xD0);
5785 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0x20);
5786
5787 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5788 AUDIO_DELAY1MS(1);
5789 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5790 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5791
5792 #if 0
5793 //set SRC back to 48KHz
5794 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xE0); // Group A SRC rate
5795 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x07);
5796 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0x50);
5797 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0x46);
5798 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5799 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x08);
5800 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0x50);
5801 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0x46);
5802 //update SYNTH
5803 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5804 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5805 AUDIO_DELAY1MS(1);
5806 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5807 //reset GroupA SRC
5808 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5809 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5810 AUDIO_DELAY1MS(1);
5811 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5812 #endif
5813 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_OFF\r\n");
5814 break;
5815
5816 default :
5817 break;
5818 }
5819 }
5820
5821
5822 ////////////////////////////////////////////////////////////////////////////////
5823 /// @brief \b Function \b Name: HAL_AUDIO_SetSystem()
5824 /// @brief \b Function \b Description: This function will load
5825 /// different audio decoder to audio system.
5826 ///
5827 /// In Mstar audio system, we can support 1 or 2 decoders.
5828 /// One is for main DTV audio or Multimedia audio player.
5829 /// Another is for second audio decode (ex: used for Audio Description purpose)
5830 ///
5831 /// @param enDecSystem \b : (En_DVB_decSystemType) decoder type
5832 /// - parameter type "MSAPI_AUD_DVB_XXXX" is decoder type for main audio decoder
5833 /// - parameter type "MSAPI_AUD_DVB2_XXXX" is decoder type for second audio decoder
5834 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)5835 MS_BOOL HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)
5836 {
5837 //MS_BOOL pas2_sel = TRUE;
5838 MS_BOOL bRet = FALSE;
5839
5840 HAL_AUDIO_SetIsDtvFlag(TRUE);
5841 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, FALSE, 0);
5842
5843 // set decoder system
5844 switch (enDecSystem)
5845 {
5846 ////////////////////////////////////////////////
5847 // Audio Decoder 1
5848 ////////////////////////////////////////////////
5849 case MSAPI_AUD_DVB_MPEG:
5850 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5851 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5852 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
5853 break;
5854
5855 case MSAPI_AUD_DVB_AC3:
5856 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DDE);
5857 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5858 AUDIO_DELAY1MS(1);
5859 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5860 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5861 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5862 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3, TRUE);
5863 break;
5864
5865 case MSAPI_AUD_DVB_AC3P:
5866 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DDE);
5867 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5868 AUDIO_DELAY1MS(1);
5869 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5870 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5871 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5872 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
5873 break;
5874
5875 case MSAPI_AUD_DVB_MP3:
5876 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5877 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5878 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MP3, TRUE);
5879 break;
5880
5881 case MSAPI_AUD_DVB_AAC:
5882 case MSAPI_AUD_DVB_MS10_DDT:
5883 if (g_AudioVars2->DolbyAACFlag == 1)
5884 {
5885 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_aac);
5886 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5887 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
5888 }
5889 else
5890 {
5891 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_gaac);
5892 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5893 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
5894 }
5895 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DDE);
5896 break;
5897
5898 case MSAPI_AUD_DVB_XPCM:
5899 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_xpcm);
5900 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5901 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
5902 break;
5903
5904 case MSAPI_AUD_DVB_RA8LBR:
5905 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ra8);
5906 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5907 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
5908 break;
5909
5910 case MSAPI_AUD_DVB_WMA:
5911 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5912 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5913 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
5914 break;
5915
5916 case MSAPI_AUD_DVB_DTS:
5917 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5918 AUDIO_DELAY1MS(1);
5919 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5920 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
5921 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5922 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5923 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
5924 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DTSE);
5925 break;
5926
5927 case MSAPI_AUD_DVB_DTSLBR:
5928 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5929 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5930 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTSLBR, TRUE);
5931 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DTSE);
5932 break;
5933
5934 case MSAPI_AUD_DVB_MS10_DDC:
5935 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5936 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5937 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDC, TRUE);
5938 break;
5939
5940 case MSAPI_AUD_DVB_WMA_PRO:
5941 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5942 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5943 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
5944 break;
5945
5946 case MSAPI_AUD_DVB_FLAC:
5947 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_flac);
5948 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5949 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
5950 break;
5951
5952 case MSAPI_AUD_DVB_VORBIS:
5953 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_vorbis);
5954 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5955 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
5956 break;
5957
5958 case MSAPI_AUD_DVB_AMR_NB:
5959 break;
5960
5961 case MSAPI_AUD_DVB_AMR_WB:
5962 break;
5963
5964 case MSAPI_AUD_DVB_DRA:
5965 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dra);
5966 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5967 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
5968 break;
5969
5970 case MSAPI_AUD_DVB_DolbyTrueHDBypass:
5971 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dolby_truhd_bypass); /* select r2 decoder to olby TrueHD bypss */
5972 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5973 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DolbyTrueHD_Bypass,TRUE); //set decoder type for HDMI Tx handler
5974 break;
5975
5976 case MSAPI_AUD_DVB_DTSHDADO:
5977 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5978 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5979 g_AudioVars2->AudioDecStatus[AU_DEC_ID1].eAudFormat = enDecSystem;
5980 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
5981 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
5982 break;
5983
5984 ////////////////////////////////////////////////
5985 // Audio Decoder 2
5986 ////////////////////////////////////////////////
5987 case MSAPI_AUD_DVB2_MPEG:
5988 case MSAPI_AUD_DVB2_MP3:
5989 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
5990 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5991 break;
5992
5993 case MSAPI_AUD_DVB2_AC3:
5994 case MSAPI_AUD_DVB2_AC3P:
5995 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
5996 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
5997 break;
5998
5999 case MSAPI_AUD_DVB2_AAC:
6000 case MSAPI_AUD_DVB2_GAAC:
6001 if (g_AudioVars2->DolbyAACFlag == 1)
6002 {
6003 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_aac);
6004 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6005 }
6006 else
6007 {
6008 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_gaac);
6009 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6010 }
6011 break;
6012
6013 case MSAPI_AUD_DVB2_DTS:
6014 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dts);
6015 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6016 break;
6017
6018 case MSAPI_AUD_DVB2_XPCM:
6019 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_xpcm);
6020 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6021 break;
6022
6023 case MSAPI_AUD_DVB2_DolbyTrueHDBypass:
6024 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dolby_truhd_bypass);
6025 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6026 break;
6027
6028 case MSAPI_AUD_DVB2_DTSHDADO:
6029 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dolby_dtshd_ado);
6030 g_AudioVars2->AudioDecStatus[AU_DEC_ID3].eAudFormat = enDecSystem;
6031 break;
6032
6033
6034 default:
6035 HAL_AUDIO_SetIsDtvFlag(FALSE);
6036 bRet = TRUE;
6037 break;
6038 }
6039
6040 return bRet;
6041 }
6042
6043 ////////////////////////////////////////////////////////////////////////////////
6044 /// @brief \b Function \b Name: HAL_AUDIO_GetDecSysSupportStatus()
6045 /// @brief \b Function \b Description: This function will report Audio Decoder support feature status when giving DecSystem type
6046 /// @param <IN> \b enDecSystem : Decoder type
6047 /// @param <RET> \b BOOL : True or False
6048 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)6049 MS_BOOL HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)
6050 {
6051 MS_BOOL SetDecSys_RtnStatus = FALSE;
6052 switch (enDecSystem)
6053 {
6054 ////////////////////////////////////////////////
6055 // Audio Decoder 1
6056 ////////////////////////////////////////////////
6057 case MSAPI_AUD_DVB_MPEG:
6058 case MSAPI_AUD_DVB_AC3:
6059 case MSAPI_AUD_DVB_AC3P:
6060 case MSAPI_AUD_DVB_MP3:
6061 case MSAPI_AUD_DVB_AAC:
6062 SetDecSys_RtnStatus = TRUE;
6063 break;
6064
6065 case MSAPI_AUD_DVB_MS10_DDT:
6066 case MSAPI_AUD_DVB_MS10_DDC:
6067 SetDecSys_RtnStatus = TRUE;
6068 break;
6069
6070 case MSAPI_AUD_DVB_XPCM:
6071 case MSAPI_AUD_DVB_RA8LBR:
6072 SetDecSys_RtnStatus = TRUE;
6073 break;
6074
6075 case MSAPI_AUD_DVB_WMA:
6076 case MSAPI_AUD_DVB_WMA_PRO:
6077 SetDecSys_RtnStatus = TRUE;
6078 break;
6079
6080 case MSAPI_AUD_DVB_DTS:
6081 SetDecSys_RtnStatus = TRUE;
6082 break;
6083
6084 case MSAPI_AUD_DVB_FLAC:
6085 SetDecSys_RtnStatus = TRUE;
6086 break;
6087
6088 case MSAPI_AUD_DVB_VORBIS:
6089 SetDecSys_RtnStatus = TRUE;
6090 break;
6091
6092 case MSAPI_AUD_DVB_AMR_NB:
6093 SetDecSys_RtnStatus = FALSE;
6094 break;
6095
6096 case MSAPI_AUD_DVB_AMR_WB:
6097 SetDecSys_RtnStatus = FALSE;
6098 break;
6099
6100 ////////////////////////////////////////////////
6101 // Audio Decoder 2
6102 ////////////////////////////////////////////////
6103 case MSAPI_AUD_DVB2_MPEG:
6104 case MSAPI_AUD_DVB2_MP3:
6105 SetDecSys_RtnStatus = TRUE;
6106 break;
6107
6108 case MSAPI_AUD_DVB2_AC3:
6109 case MSAPI_AUD_DVB2_AC3P:
6110 SetDecSys_RtnStatus = TRUE;
6111 break;
6112
6113 case MSAPI_AUD_DVB2_AAC:
6114 SetDecSys_RtnStatus = TRUE;
6115 break;
6116
6117 case MSAPI_AUD_DVB2_DDE:
6118 SetDecSys_RtnStatus = FALSE;
6119 break;
6120
6121 case MSAPI_AUD_DVB2_DTSE:
6122 SetDecSys_RtnStatus = FALSE;
6123 break;
6124
6125 case MSAPI_AUD_DVB2_XPCM:
6126 SetDecSys_RtnStatus = TRUE;
6127 break;
6128
6129 case MSAPI_AUD_DVB2_KTV:
6130 SetDecSys_RtnStatus = TRUE;
6131 break;
6132
6133 case MSAPI_AUD_DVB_TONE:
6134 case MSAPI_AUD_DVB_NONE:
6135 case MSAPI_AUD_DVB2_NONE:
6136 default:
6137 SetDecSys_RtnStatus = FALSE;
6138 break;
6139 }
6140 return(SetDecSys_RtnStatus);
6141 }
6142
6143 ////////////////////////////////////////////////////////////////////////////////
6144 /// @brief \b Function \b Name: HAL_AUDIO_AlgReloadCode()
6145 /// @brief \b Function \b Description: This routine is used to reload DSP code
6146 /// @param dspCodeType \b :
6147 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
6148 /// FALSE--DEC-DSP reload code fail
6149 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)6150 MS_BOOL HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
6151 {
6152 // No DEC-DSP in Monaco
6153 return TRUE;
6154 }
6155
6156 ////////////////////////////////////////////////////////////////////////////////
6157 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Check()
6158 /// @brief \b Function \b Description: Check if ALSA Interface is supported
6159 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
6160 /// @param <OUT> \b MS_BOOL : return TRUE if it's supported, else return FALSE
6161 /// @param <RET> \b NONE :
6162 /// @param <GLOBAL> \b NONE :
6163 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Check(void)6164 MS_BOOL HAL_AUDIO_ALSA_Check(void)
6165 {
6166 return TRUE;
6167 }
6168
6169 ////////////////////////////////////////////////////////////////////////////////
6170 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Enable()
6171 /// @brief \b Function \b Description: Enable/ Disable the path of ALSA
6172 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
6173 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
6174 /// @param <RET> \b NONE :
6175 /// @param <GLOBAL> \b NONE :
6176 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)6177 MS_BOOL HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)
6178 {
6179 if (bEnable == TRUE)
6180 {
6181 /* Set as GAME mode */
6182 HAL_AUDIO_SetInputPath(AUDIO_DSP3_DVB_INPUT , AUDIO_PATH_5);
6183 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
6184 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
6185 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
6186 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
6187
6188 return TRUE;
6189 }
6190 else
6191 {
6192 /* Do nothing for the moment */
6193 return FALSE;
6194 }
6195 }
6196
6197 ////////////////////////////////////////////////////////////////////////////////
6198 /// @brief \b Function \b Name: HAL_AUDIO_Alg2ReloadCode()
6199 /// @brief \b Function \b Description: This routine is used to reload the algorithm in se-dsp .
6200 /// @param dspCodeType \b : information of algorithm code
6201 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
6202 /// FALSE--DEC-DSP reload code fail
6203 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)6204 MS_BOOL HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
6205 {
6206 int time_out;
6207 MS_BOOL ret_status = FALSE;
6208
6209 HAL_MAD2_SetDspIDMA();
6210 // Enter MCU/DSP hand-shake
6211 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6212 {
6213 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
6214 }
6215 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6216 {
6217 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG/0x100);
6218 }
6219 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6220 {
6221 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_BEG/0x100);
6222 }
6223 else
6224 {
6225 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_BEG/0x100);
6226 }
6227
6228 // PIO[8] interrupt
6229 HAL_MAD2_TriggerPIO8();
6230
6231 //Wait Dsp Start reload Ack
6232 time_out = 0;
6233 while(time_out++<2000)
6234 {
6235 if(HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
6236 break;
6237 AUDIO_DELAY1MS(1);
6238 }
6239 if(time_out>=2000)
6240 {
6241 DBG_AUDIO_ERROR(" DSP Reload timeOut1: %d\r\n",time_out);
6242 return FALSE;
6243 }
6244
6245 // Change to IDMA Port
6246 HAL_MAD2_SetDspIDMA();
6247
6248 // Start to Reload DSP code
6249 ret_status = HAL_AUDSP_DspLoadCode(dspCodeType);
6250 HAL_AUDIO_SetDsp2CodeType(dspCodeType, ret_status);
6251
6252 // Enter MCU/DSP hand-shake
6253 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6254 {
6255 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_END/0x100);
6256 }
6257 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
6258 {
6259 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END/0x100);
6260 }
6261 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
6262 {
6263 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_END/0x100);
6264 }
6265 else
6266 {
6267 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_END/0x100);
6268 }
6269
6270 HAL_MAD2_TriggerPIO8();
6271
6272 // Wait Dsp End Reload Ack
6273 time_out = 0;
6274 while(time_out++<3000)
6275 {
6276 if(HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
6277 break;
6278 AUDIO_DELAY1MS(1);
6279 }
6280
6281 if(time_out>=3000)
6282 {
6283 DBG_AUDIO_ERROR(" DSP Reload timeOut2: %d\r\n",time_out);
6284 return FALSE;
6285 }
6286
6287 DBG_AUDIO("HAL_AUDIO_SeReloadCode finish\r\n");
6288
6289 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
6290
6291 return TRUE;
6292
6293 }
6294
6295 ////////////////////////////////////////////////////////////////////////////////
6296 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeDoneFlag() @@Cathy
6297 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
6298 /// @param <IN> \b NONE :
6299 /// @param <OUT> \b NONE :
6300 /// @param <RET> \b NONE :
6301 /// @param <GLOBAL> \b NONE :
6302 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeDoneTag(void)6303 MS_U16 HAL_AUDIO_GetUniDecodeDoneTag(void)
6304 {
6305 MS_U16 temp1, temp2, i;
6306
6307 for (i = 0; i < 100; i++)
6308 {
6309 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6310 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6311
6312 if (temp1 == temp2)
6313 {
6314 return (temp1);
6315 }
6316 }
6317
6318 return 0;
6319 }
6320
6321 ////////////////////////////////////////////////////////////////////////////////
6322 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeFrameCnt()
6323 /// @brief \b Function \b Description: This function is used to get the Decoder decoded frame count
6324 /// @param <IN> \b NONE:
6325 /// @param <OUT> \b NONE:
6326 /// @param <RET> \b NONE:
6327 /// @param <GLOBAL> \b NONE:
6328 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)6329 MS_U16 HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)
6330 {
6331 MS_U16 temp1, temp2, i;
6332 Audio_id r2AudioID = ADEC1;
6333
6334
6335 if (eDSPId == AU_DEC_ID3)
6336 {
6337 r2AudioID = ADEC2;
6338 }
6339
6340 for ( i = 0; i < 100; i++ )
6341 {
6342 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6343 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6344
6345 if ( temp1 == temp2 )
6346 {
6347 return (temp1);
6348 }
6349 }
6350
6351 return 0;
6352 }
6353
6354 //******************************************************************************
6355 // [Function Name]:
6356 // HAL_AUDIO_PTS_info
6357 // [Description]:
6358 // get PTS and OS time or set to reset these reference
6359 // [Arguments]:
6360 //
6361 //*******************************************************************************
HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info)6362 void HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info )
6363 {
6364 AUDIO_PTS_INFO PTS_info;
6365
6366 memcpy((void *)&PTS_info,(void *)access_PTS_info,sizeof(AUDIO_PTS_INFO));
6367
6368 // printf("HAL_AUDIO_PTS_info((0x%x, %d, %lld))\n",(unsigned int)access_PTS_info,(int)PTS_info.os_Time,PTS_info.curPTS);
6369 if(PTS_info.set2Clr) //setting value
6370 {
6371 curr_OS_Time = PTS_info.os_Time;
6372 curr_PTS = PTS_info.curPTS;
6373 }
6374 else // get PTS information
6375 {
6376
6377 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6378
6379 PTS_info.set2Clr = 0 ;
6380 PTS_info.os_Time = curr_OS_Time;
6381 PTS_info.curPTS = curr_PTS;
6382
6383 memcpy((void *)access_PTS_info,(void *)&PTS_info,sizeof(AUDIO_PTS_INFO));
6384
6385 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6386 }
6387 }
6388
HAL_AUDIO_DmaWriter_Init(void)6389 void HAL_AUDIO_DmaWriter_Init(void)
6390 {
6391 return;
6392 }
6393
6394 ////////////////////////////////////////////////////////////////////////////////
6395 /// @brief \b Function \b Name: HAL_AUDIO_RebootDecDSP()
6396 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RebootDecDSP(void)6397 void HAL_AUDIO_RebootDecDSP(void)
6398 {
6399 AU_DVB_DECCMD deccmd_status;
6400 AUD_ERRMSG("\n*MAD Auto-Recovery DEC-R2* \n");
6401
6402 HALAUDIO_CHECK_SHM_INIT;
6403
6404 g_AudioVars2->g_u8AudioCrashFlag = TRUE;
6405
6406 deccmd_status = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
6407
6408 HAL_AUDIO_BackupMailbox();
6409
6410 // Reset MAD module
6411 HAL_MAD_RSTMAD_DisEn_MIUREQ();
6412 AUDIO_DELAY1MS(2);
6413
6414 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, FALSE, 0); // Audio SIF channel enable setting -> disable
6415 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 0, 0);
6416
6417 AUDIO_DELAY1MS(2);
6418
6419 AUD_DBGMSG("*** Load code and reset DEC-R2 \n");
6420
6421 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
6422 HAL_MAD2_SetMemInfo();
6423
6424 HAL_AUDSP_DECR2LoadCode(); // Reload R2 code
6425
6426 HAL_MAD_SetDecCmd(deccmd_status);
6427
6428 AUDIO_DELAY1MS(50);
6429 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 1, 0);
6430 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0); // Audio SIF channel enable setting -> enable
6431 HAL_AUDIO_RestoreMailbox();
6432 }
6433
6434 ////////////////////////////////////////////////////////////////////////////////
6435 /// @brief \b Function \b Name: HAL_AUDIO_DspReboot()
6436 /// @brief \b Function \b Description: This routine is used to do dsp reboot and some specific setting
6437 /// @param <IN> \b eType : param
6438 /// @param <RET> \b NONE :
6439 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspReboot(MS_U8 alive)6440 void HAL_AUDIO_DspReboot(MS_U8 alive)
6441 {
6442 alive = alive;
6443 }
6444
6445
6446 ////////////////////////////////////////////////////////////////////////////////
6447 /// @brief \b Function \b Name: HAL_AUDIO_ReadDspCounter()
6448 /// @brief \b Function \b Description: Read the DSP running counter
6449 /// @param CounterType \b :
6450 /// - DSP_DEC_MAIN_COUNTER ==> Decoder DSP Main loop counter
6451 /// - DSP_DEC_TIMER_COUNTER ==> Decoder Timer counter
6452 /// - DSP_SE_MAIN_COUNTER ==> SE DSP Main loop counter
6453 /// - DSP_SE_TIMER_COUNTER ==> SE Timer counter
6454 /// - DSP_SE_ISR_COUNTER ==> SE Interrupt ISR counter
6455 /// @return MS_U8 \b : Running counter value
6456 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)6457 MS_U8 HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)
6458 {
6459 MS_U8 u8CounterValue=0;
6460
6461 switch(CounterType)
6462 {
6463 case DSP_DEC_MAIN_COUNTER:
6464 case DEC_R2_MAIN_COUNTER:
6465 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_MAIN_COUNTER);
6466 break;
6467
6468 case DSP_DEC_TIMER_COUNTER:
6469 case DEC_R2_TIMER_COUNTER:
6470 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_TIMER_COUNTER);
6471 break;
6472
6473 case DSP_SE_MAIN_COUNTER:
6474 case SND_R2_MAIN_COUNTER:
6475 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_COUNTER);
6476 break;
6477
6478 case DSP_SE_TIMER_COUNTER:
6479 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_TIMER_COUNTER);
6480 break;
6481
6482 case DSP_SE_ISR_COUNTER:
6483 case SND_R2_TIMER_COUNTER:
6484 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_ISR_COUNTER);
6485 break;
6486
6487 default:
6488 break;
6489 }
6490 return u8CounterValue;
6491 }
6492
6493
6494 ////////////////////////////////////////////////////////////////////////////////
6495 /// @brief \b Function \b Name: HAL_AuProcessPowerDown_Wait()
6496 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
6497 /// @param bEnable \b : TRUE --Not wait,
6498 /// FALSE--wait
6499 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)6500 void HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)
6501 {
6502 bEnable = bEnable;
6503 }
6504
6505 ////////////////////////////////////////////////////////////////////////////////
6506 /// @brief \b Function \b Name: HAL_AUDIO_SendIntrupt()
6507 /// @brief \b Function \b Description: send a PIO8 interrupt to DSP
6508 /// @param bDspType \b :
6509 /// @param u8Cmd \b :
6510 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)6511 void HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)
6512 {
6513 if (bDspType == DSP_DEC)
6514 {
6515 HAL_MAD_SetPIOCmd(u8Cmd);
6516 HAL_MAD_TriggerPIO8();
6517 }
6518 else
6519 {
6520 HAL_MAD2_SetPIOCmd(u8Cmd);
6521 HAL_MAD2_TriggerPIO8();
6522 }
6523 }
6524
6525 ////////////////////////////////////////////////////////////////////////////////
6526 /// @brief \b Function \b Name: HAL_AUDIO_SeSystemLoadCode()
6527 /// @brief \b Function \b Description: This routine is used to load DSP code for SE-DSP .
6528 /// @return MS_BOOL \b : TRUE --DEC-DSP load code okay,
6529 /// FALSE--DEC-DSP load code fail
6530 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeSystemLoadCode(void)6531 MS_BOOL HAL_AUDIO_SeSystemLoadCode(void)
6532 {
6533 MS_U16 time_out = 0;
6534
6535 HAL_MAD2_SetDspIDMA();
6536
6537 AUD_DBGMSG("MDrv_AUDIO_SeSystemLoadCode() \r\n");
6538
6539 HAL_AUDSP_DspLoadCode(AU_SE_SYSTEM);
6540
6541 //Wait Dsp init finished Ack
6542 #ifndef MBOOT_PLAY_MELODY
6543 while(time_out++<100) {
6544 if(HAL_MAD2_GetLoadCodeAck() == 0xE3)
6545 break;
6546 AUDIO_DELAY1MS(2);
6547 }
6548 #endif
6549
6550 if(time_out>=100) {
6551 AUD_ERRMSG("DSP2 Re-Active\n");
6552 }
6553 else {
6554 AUD_DBGMSG("audio DSP_SE LoadCode success..\n");
6555 }
6556
6557 //inform DSP to start to run
6558 HAL_MAD2_SetMcuCmd(0xF3);
6559
6560 return TRUE;
6561 }
6562
6563 ////////////////////////////////////////////////////////////////////////////////
6564 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6565 ////////////////////////////////////////////////////////////////////////////////
6566 ////////////////////////////////////////////////////////////////////////////////
6567 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6568 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecoderLoadCode(void)6569 MS_BOOL HAL_AUDIO_DecoderLoadCode(void)
6570 {
6571
6572 HAL_MAD_SetDspIDMA();
6573
6574 AUD_DBGMSG("MDrv_AUDIO_DecoderLoadCode() \r\n");
6575
6576 #ifdef MBOOT_PLAY_MELODY
6577 HAL_AUDSP_DspLoadCode(AU_DVB_STANDARD_MP3); //MBoot
6578 #endif
6579
6580 HAL_AUDSP_DspLoadCode(AU_DEC_SYSTEM);
6581
6582 //enable SIF Channel
6583 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0);
6584
6585 //inform DSP to start to run
6586 HAL_MAD_SetMcuCmd(0xF3);
6587
6588 AUD_DBGMSG("DEC System code download finished!\r\n");
6589 return TRUE;
6590 }
6591
6592 ////////////////////////////////////////////////////////////////////////////////
6593 /// @brief \b Function \b Name: HAL_AUDIO_init()
6594 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Init(MS_BOOL Initype)6595 MS_BOOL HAL_AUDIO_Init(MS_BOOL Initype)
6596 {
6597 Initype = Initype;
6598 return Initype;
6599 }
6600
6601 ////////////////////////////////////////////////////////////////////////////////
6602 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_TX_SetMode()
6603 /// @brief \b Function \b Description: This routine is used to set HDMI output mode
6604 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType,AUDIO_SOURCE_INFO_TYPE eSource)6605 void HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType, AUDIO_SOURCE_INFO_TYPE eSource)
6606 {
6607 outType = outType;
6608 eSource = eSource;
6609 }
6610
6611 ////////////////////////////////////////////////////////////////////////////////
6612 /// @brief \b Function \b Name: HAL_AUDIO_PCMCaptureInit()
6613 /// @brief \b Function \b Description: Select source for pcm capture
6614 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6615 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6616 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6617 /// @param <RET> \b NONE :
6618 /// @param <GLOBAL> \b NONE :
6619 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID,const AUDIO_CAPTURE_SOURCE_TYPE eSource)6620 MS_BOOL HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID, const AUDIO_CAPTURE_SOURCE_TYPE eSource)
6621 {
6622 MS_BOOL ret = TRUE;
6623
6624 switch(eID)
6625 {
6626 case E_DEVICE0:
6627 g_pcm_capture_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
6628 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6629 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6630 break;
6631
6632 case E_DEVICE1:
6633 g_pcm_capture2_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
6634 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6635 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6636 break;
6637
6638 default:
6639 printf("\r\n =====PCMCapture_Init : unsupported DEVICE TYPE!!!=======");
6640 ret = FALSE;
6641 break;
6642 }
6643
6644 return ret;
6645 }
6646
6647 ////////////////////////////////////////////////////////////////////////////////
6648 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Start()
6649 /// @brief \b Function \b Description: captrue pcm data to DDR
6650 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6651 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6652 /// @param <RET> \b NONE :
6653 /// @param <GLOBAL> \b NONE :
6654 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)6655 MS_BOOL HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)
6656 {
6657 MS_BOOL ret = TRUE;
6658
6659 switch(eID)
6660 {
6661 case E_DEVICE0:
6662 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); // start
6663 break;
6664
6665 case E_DEVICE1:
6666 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); //start
6667 break;
6668
6669 default:
6670 printf("\r\n =====PCMCapture_Start : unsupported DEVICE TYPE!!!=======");
6671 ret = FALSE;
6672 break;
6673 }
6674
6675 return ret;
6676 }
6677
6678
6679 ////////////////////////////////////////////////////////////////////////////////
6680 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Stop()
6681 /// @brief \b Function \b Description: stop captrue pcm data from DDR
6682 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6683 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6684 /// @param <RET> \b NONE :
6685 /// @param <GLOBAL> \b NONE :
6686 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)6687 MS_BOOL HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)
6688 {
6689 MS_BOOL ret = TRUE;
6690 MS_U8 flagCount = 0;
6691
6692 switch(eID)
6693 {
6694 case E_DEVICE0:
6695 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0); // stop
6696 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0);
6697 do
6698 {
6699 MsOS_DelayTask(2);
6700 flagCount ++;
6701 if (flagCount > 100)
6702 {
6703 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6704 break;
6705 }
6706 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) > 0);
6707 break;
6708
6709 case E_DEVICE1:
6710 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0); //stop
6711 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0);
6712 do
6713 {
6714 MsOS_DelayTask(2);
6715 flagCount ++;
6716 if (flagCount > 100)
6717 {
6718 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6719 break;
6720 }
6721 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) > 0);
6722 break;
6723
6724 default:
6725 printf("\r\n =====PCMCapture_Stop : unsupported DEVICE TYPE!!!=======");
6726 ret = FALSE;
6727 break;
6728 }
6729
6730 return ret;
6731 }
6732
6733
6734 ////////////////////////////////////////////////////////////////////////////////
6735 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Read()
6736 /// @brief \b Function \b Description: captrue pcm data from DDR to device
6737 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6738 /// @param <IN> \b void* : destination buffer pointer
6739 /// @param <IN> \b MS_U32 : buffer size need transfered in byte
6740 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6741 /// @param <RET> \b NONE :
6742 /// @param <GLOBAL> \b NONE :
6743 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID,void * buffer,const MS_U32 bytes)6744 MS_BOOL HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID, void *buffer, const MS_U32 bytes)
6745 {
6746 MS_BOOL ret = TRUE;
6747 MS_VIRT buffer_tmp = (MS_VIRT)buffer;
6748 MS_U32 request_size = bytes;
6749 MS_U32 read_ptr_mailbox = 0;
6750 MS_U32 write_ptr_mailbox = 0;
6751 MS_PHY pcm_capture_base_addr_tmp = 0;
6752 MS_PHY pcm_capture_read_addr_tmp = 0;
6753 MS_PHY pcm_capture_write_addr_tmp = 0;
6754 MS_S32 avail_size = 0;
6755
6756 switch(eID)
6757 {
6758 case E_DEVICE0:
6759 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE_DDR_RdPtr;
6760 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE_DDR_WrPtr;
6761 pcm_capture_base_addr_tmp = g_pcm_capture_base_addr;
6762 break;
6763
6764 case E_DEVICE1:
6765 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr;
6766 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr;
6767 pcm_capture_base_addr_tmp = g_pcm_capture2_base_addr;
6768 break;
6769
6770 default:
6771 printf("\r\n =====PCMCapture_Read : unsupported DEVICE TYPE!!!=======\n");
6772 ret = FALSE;
6773 break;
6774 }
6775
6776 if (ret == FALSE)
6777 return ret;
6778
6779 //get read & write pointer
6780 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(read_ptr_mailbox) * BYTES_IN_MIU_LINE);
6781 pcm_capture_write_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(write_ptr_mailbox) * BYTES_IN_MIU_LINE);
6782 avail_size = (MS_S32)(pcm_capture_write_addr_tmp - pcm_capture_read_addr_tmp);
6783 if (avail_size < 0)
6784 {
6785 avail_size += (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE);
6786 }
6787
6788 // if overflow , return false
6789 if (avail_size >= ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE - DSP2_PCM_CAPTURE_COPY_LINESIZE) * BYTES_IN_MIU_LINE))
6790 {
6791 printf("\r\n ===== PCM DATA OVERFLOW !!!=======\n");
6792
6793 HAL_AUDIO_PCMCapture_Stop(eID);
6794 HAL_AUDIO_PCMCapture_Start(eID);
6795 ret = FALSE;
6796 return ret;
6797 }
6798
6799 // if no enough data, do nothing.
6800 if (avail_size < request_size)
6801 {
6802 ret = FALSE;
6803 return ret;
6804 }
6805
6806 //copy data to destination.
6807 do
6808 {
6809 MS_U32 size_tmp = (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)) - pcm_capture_read_addr_tmp;
6810
6811 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
6812 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
6813
6814 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(pcm_capture_read_addr_tmp), size_tmp);
6815 MsOS_FlushMemory();
6816
6817 pcm_capture_read_addr_tmp += size_tmp;
6818 if (pcm_capture_read_addr_tmp == (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)))
6819 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp;
6820
6821 buffer_tmp += size_tmp;
6822 avail_size -= size_tmp;
6823 request_size -= size_tmp;
6824
6825 } while (request_size > 0);
6826
6827 //update read pointer
6828 HAL_AUDIO_WriteReg(read_ptr_mailbox, ((pcm_capture_read_addr_tmp - pcm_capture_base_addr_tmp) / BYTES_IN_MIU_LINE));
6829
6830 return ret;
6831 }
6832
6833 ////////////////////////////////////////////////////////////////////////////////
6834 /// @brief \b Function \b Name: HAL_AUDIO_SetDataCaptureSource()
6835 /// @brief \b Function \b Description: Select source for data capture
6836 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6837 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6838 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6839 /// @param <RET> \b NONE :
6840 /// @param <GLOBAL> \b NONE :
6841 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID,AUDIO_CAPTURE_SOURCE_TYPE eSource)6842 MS_BOOL HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID, AUDIO_CAPTURE_SOURCE_TYPE eSource)
6843 {
6844 MS_U32 u32ControlAddress;
6845 MS_BOOL ret = TRUE;
6846
6847 switch(eID)
6848 {
6849 case E_DEVICE0:
6850 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL;
6851 break;
6852
6853 case E_DEVICE1:
6854 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
6855 break;
6856
6857 default:
6858 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
6859 return FALSE;
6860 }
6861
6862 switch(eSource)
6863 {
6864 case E_CAPTURE_CH5:
6865 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH5);
6866 break;
6867
6868 case E_CAPTURE_CH6:
6869 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH6);
6870 break;
6871
6872 case E_CAPTURE_CH7:
6873 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH7);
6874 break;
6875
6876 case E_CAPTURE_CH8:
6877 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH8);
6878 break;
6879
6880 case E_CAPTURE_ADC:
6881 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
6882 break;
6883
6884 case E_CAPTURE_ADC2:
6885 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
6886 break;
6887
6888 case E_CAPTURE_PCM_SE:
6889 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_Raw_Delay_SE);
6890 break;
6891
6892 case E_CAPTURE_ADC1_AUIN0_INPUT:
6893 case E_CAPTURE_ADC1_AUIN1_INPUT:
6894 case E_CAPTURE_ADC1_AUIN2_INPUT:
6895 case E_CAPTURE_ADC1_AUIN3_INPUT:
6896 case E_CAPTURE_ADC1_AUIN4_INPUT:
6897 case E_CAPTURE_ADC1_AUIN5_INPUT:
6898 case E_CAPTURE_ADC1_AUMIC_INPUT:
6899 {
6900 MS_U8 u8temp = 0;
6901
6902 //check if ADC1 is occupied by main or sub channel
6903 if((LONIBBLE(g_audioSrcType) == 2 || LONIBBLE(g_audioSubSrcType) == 2))
6904 {
6905 printf("===The audio capture setting is failed by the following reason:=== \n");
6906 printf("The input setting of ADC1 is occupied by main or sub channel\n");
6907 ret = FALSE;
6908 break;
6909 }
6910
6911 //switch source of ADC1
6912 if (eSource == E_CAPTURE_ADC1_AUIN0_INPUT)
6913 {
6914 u8temp = 0x00;
6915 }
6916 else if (eSource == E_CAPTURE_ADC1_AUIN1_INPUT)
6917 {
6918 u8temp = 0x01;
6919 }
6920 else if (eSource == E_CAPTURE_ADC1_AUIN2_INPUT)
6921 {
6922 u8temp = 0x02;
6923 }
6924 else if (eSource == E_CAPTURE_ADC1_AUIN3_INPUT)
6925 {
6926 u8temp = 0x03;
6927 }
6928 else if (eSource == E_CAPTURE_ADC1_AUIN4_INPUT)
6929 {
6930 u8temp = 0x04;
6931 }
6932 else if (eSource == E_CAPTURE_ADC1_AUIN5_INPUT)
6933 {
6934 u8temp = 0x05;
6935 }
6936 else if (eSource == E_CAPTURE_ADC1_AUMIC_INPUT)
6937 {
6938 u8temp = 0x07;
6939 }
6940
6941 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, (u8temp<<4));
6942 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
6943 break;
6944 }
6945
6946 case E_CAPTURE_ADC2_AUIN0_INPUT:
6947 case E_CAPTURE_ADC2_AUIN1_INPUT:
6948 case E_CAPTURE_ADC2_AUIN2_INPUT:
6949 case E_CAPTURE_ADC2_AUIN3_INPUT:
6950 case E_CAPTURE_ADC2_AUIN4_INPUT:
6951 case E_CAPTURE_ADC2_AUIN5_INPUT:
6952 case E_CAPTURE_ADC2_AUMIC_INPUT:
6953 {
6954 MS_U8 u8temp = 0;
6955
6956 //check if ADC2 is occupied by main or sub channel
6957 if((LONIBBLE(g_audioSrcType) == 9 || LONIBBLE(g_audioSubSrcType) == 9))
6958 {
6959 printf("===The audio capture setting is faiedl by the following reason:=== \n");
6960 printf("The input setting of ADC2 is occupied by main or sub channel \n");
6961 ret = FALSE;
6962 break;
6963 }
6964
6965 //switch source of ADC2
6966 if (eSource == E_CAPTURE_ADC2_AUIN0_INPUT)
6967 {
6968 u8temp = 0x00;
6969 }
6970 else if (eSource == E_CAPTURE_ADC2_AUIN1_INPUT)
6971 {
6972 u8temp = 0x01;
6973 }
6974 else if (eSource == E_CAPTURE_ADC2_AUIN2_INPUT)
6975 {
6976 u8temp = 0x02;
6977 }
6978 else if (eSource == E_CAPTURE_ADC2_AUIN3_INPUT)
6979 {
6980 u8temp = 0x03;
6981 }
6982 else if (eSource == E_CAPTURE_ADC2_AUIN4_INPUT)
6983 {
6984 u8temp = 0x04;
6985 }
6986 else if (eSource == E_CAPTURE_ADC2_AUIN5_INPUT)
6987 {
6988 u8temp = 0x05;
6989 }
6990 else if (eSource == E_CAPTURE_ADC2_AUMIC_INPUT)
6991 {
6992 u8temp = 0x07;
6993 }
6994 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp);
6995 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
6996 break;
6997 }
6998
6999 default:
7000 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
7001 ret = FALSE;
7002 break;
7003 }
7004
7005 return ret;
7006 }
7007
_AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)7008 MS_BOOL _AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
7009 {
7010 int time_out;
7011
7012 code_type = code_type;
7013 if ( eDspId >= AUDIO_DSP_ID_R2 )
7014 {
7015 HALAUDIO_ERROR ("%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
7016 return FALSE;
7017 }
7018
7019 if ( eDspId == AUDIO_DSP_ID_DEC )
7020 {
7021
7022 // PIO[8] interrupt
7023 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
7024 HAL_MAD_TriggerPIO8();
7025
7026 //Wait Dsp Start reload Ack
7027 time_out = 0;
7028 while ( time_out++ < 1000 )
7029 {
7030 if ( HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1 )
7031 break;
7032
7033 AUDIO_DELAY1MS(2);
7034 }
7035 if ( time_out >= 1000 )
7036 {
7037 HALAUDIO_ERROR (" DSP Re-active1\r\n");
7038 return FALSE;
7039 }
7040
7041 // Change to IDMA Port
7042 HAL_MAD_SetDspIDMA();
7043 }
7044 else if ( eDspId == AUDIO_DSP_ID_SND )
7045 {
7046 Dvb2DecCmd_tmp = HAL_AUDIO_Se_Status();
7047 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP); // Stop
7048
7049 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
7050
7051 // Reset MAD module
7052 HAL_MAD2_DisEn_MIUREQ();
7053
7054 HAL_MAD2_SetDspIDMA();
7055 // Enter MCU/DSP hand-shake
7056 if (((code_type & 0xF0) == 0xB0))
7057 {
7058 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG >> 8);
7059 }
7060 else if (((code_type & 0xF0) == 0xD0))
7061 {
7062 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_BEG >> 8);
7063 }
7064 else
7065 {
7066 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_BEG >> 8);
7067 }
7068
7069 // PIO[8] interrupt
7070 HAL_MAD2_TriggerPIO8();
7071
7072 //Wait Dsp Start reload Ack
7073 time_out = 0;
7074 while ( time_out++ < 2000 )
7075 {
7076 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1 )
7077 {
7078 break;
7079 }
7080
7081 AUDIO_DELAY1MS(1);
7082 }
7083
7084 if ( time_out >= 2000 )
7085 {
7086 HALAUDIO_ERROR (" SND DSP Reload timeOut1: %d\r\n", time_out);
7087 return FALSE;
7088 }
7089
7090 // Change to IDMA Port
7091 HAL_MAD2_SetDspIDMA();
7092 }
7093
7094 return TRUE;
7095 }
7096
_AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)7097 MS_BOOL _AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
7098 {
7099 int time_out;
7100
7101 code_type = code_type;
7102
7103 if ( eDspId >= AUDIO_DSP_ID_R2 )
7104 {
7105 HALAUDIO_ERROR ("%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
7106 return FALSE;
7107 }
7108
7109 if ( eDspId == AUDIO_DSP_ID_DEC )
7110 {
7111
7112 // PIO[8] interrupt
7113 HAL_MAD_SetPIOCmd(0xEE); // just not enter DSP MHEG5_isr
7114 HAL_MAD_TriggerPIO8();
7115
7116 // Wait Dsp End Reload Ack
7117 time_out = 0;
7118 while(time_out++<1500)
7119 {
7120 if(HAL_MAD_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
7121 {
7122 break;
7123 }
7124 AUDIO_DELAY1MS(2);
7125 }
7126
7127 if(time_out>=1500)
7128 {
7129 HALAUDIO_ERROR (" DSP Re-active2\r\n");
7130 return FALSE;
7131 }
7132
7133 HAL_MAD_SetMcuCmd(0x00); // In T3 T8, clear 0x2D9C after reload finish
7134 }
7135 else if ( eDspId == AUDIO_DSP_ID_SND )
7136 {
7137 // Enter MCU/DSP hand-shake
7138 if (((code_type & 0xF0) == 0xB0))
7139 {
7140 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END >> 8);
7141 }
7142 else if (((code_type & 0xF0) == 0xD0))
7143 {
7144 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_END >> 8);
7145 }
7146 else
7147 {
7148 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_DTV_END >> 8);
7149 }
7150
7151 HAL_MAD2_TriggerPIO8();
7152
7153 // Wait Dsp End Reload Ack
7154 time_out = 0;
7155 while ( time_out++ < 3000 )
7156 {
7157 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2 )
7158 {
7159 break;
7160 }
7161
7162 AUDIO_DELAY1MS(1);
7163 }
7164
7165 if ( time_out >= 3000 )
7166 {
7167 HALAUDIO_ERROR (" SND DSP Reload timeOut2\r\n");
7168 return FALSE;
7169 }
7170
7171 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
7172
7173 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
7174 HAL_MAD_SetDSP2DecCmd((AU_DVB_DECCMD) Dvb2DecCmd_tmp);
7175 }
7176
7177 return TRUE;
7178 }
7179
HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId,En_DVB_decSystemType Param)7180 MS_BOOL HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId, En_DVB_decSystemType Param)
7181 {
7182 MS_U32 regDecoderType = REG_R2_DECODE1_TYPE;
7183 MS_BOOL bRet = TRUE;
7184
7185 if ( DecId == AU_DEC_ID3 )
7186 regDecoderType = REG_R2_DECODE2_TYPE;
7187 else if( DecId == AU_DEC_ID1)
7188 regDecoderType = REG_R2_DECODE1_TYPE;
7189 else if( DecId == AU_DEC_ID2)
7190 {
7191 // AU_DEC_ID2 only for ATV SIF
7192 // For other case should not use AU_DEC_ID2
7193 return bRet;
7194 }
7195
7196 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = Param;
7197
7198 switch ( Param )
7199 {
7200 case MSAPI_AUD_DVB_MPEG:
7201 case MSAPI_AUD_DVB_MP3:
7202 HAL_AUR2_WriteByte(regDecoderType, adec_type_mpeg);
7203 if (DecId == AU_DEC_ID3)
7204 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
7205 else
7206 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
7207 break;
7208
7209 case MSAPI_AUD_DVB_MS10_DDC:
7210 case MSAPI_AUD_DVB_AC3P:
7211 case MSAPI_AUD_DVB_AC3:
7212 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7213 HAL_AUR2_WriteByte(regDecoderType, adec_type_ac3);
7214 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DDE);
7215
7216 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
7217 AUDIO_DELAY1MS(1);
7218 if (DecId == AU_DEC_ID3)
7219 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
7220 else
7221 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
7222 break;
7223
7224 case MSAPI_AUD_DVB_AAC:
7225 case MSAPI_AUD_DVB_MS10_DDT:
7226 if (g_AudioVars2->DolbyAACFlag == 1)
7227 {
7228 HAL_AUR2_WriteByte(regDecoderType, adec_type_aac);
7229 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
7230 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
7231 }
7232 else
7233 {
7234 HAL_AUR2_WriteByte(regDecoderType, adec_type_gaac);
7235 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
7236 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_DDE);
7237 }
7238
7239 if (DecId == AU_DEC_ID3)
7240 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
7241 else
7242 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
7243 break;
7244
7245 case MSAPI_AUD_DVB_XPCM:
7246 HAL_AUR2_WriteByte(regDecoderType, adec_type_xpcm);
7247 if (DecId == AU_DEC_ID3)
7248 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
7249 else
7250 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
7251 break;
7252
7253 case MSAPI_AUD_DVB_RA8LBR:
7254 HAL_AUR2_WriteByte(regDecoderType, adec_type_ra8);
7255 if (DecId == AU_DEC_ID3)
7256 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7257 else
7258 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7259 break;
7260
7261 case MSAPI_AUD_DVB_WMA:
7262 HAL_AUR2_WriteByte(regDecoderType, adec_type_wma);
7263 if (DecId == AU_DEC_ID3)
7264 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA, TRUE);
7265 else
7266 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
7267 break;
7268
7269 case MSAPI_AUD_DVB_DTS:
7270 case MSAPI_AUD_DVB_DTSLBR:
7271 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7272 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7273 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7274 if (DecId == AU_DEC_ID3)
7275 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7276 else
7277 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7278 break;
7279
7280 case MSAPI_AUD_DVB_WMA_PRO:
7281 HAL_AUR2_WriteByte(regDecoderType, adec_type_wmap);
7282 if (DecId == AU_DEC_ID3)
7283 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7284 else
7285 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7286 break;
7287
7288 case MSAPI_AUD_DVB_DRA:
7289 HAL_AUR2_WriteByte(regDecoderType, adec_type_dra);
7290 if (DecId == AU_DEC_ID3)
7291 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DRA, TRUE);
7292 else
7293 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
7294 break;
7295
7296 case MSAPI_AUD_DVB_FLAC:
7297 HAL_AUR2_WriteByte(regDecoderType, adec_type_flac);
7298 if (DecId == AU_DEC_ID3)
7299 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_FLAC, TRUE);
7300 else
7301 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
7302 break;
7303
7304 case MSAPI_AUD_DVB_VORBIS:
7305 HAL_AUR2_WriteByte(regDecoderType, adec_type_vorbis);
7306 if (DecId == AU_DEC_ID3)
7307 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7308 else
7309 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7310 break;
7311
7312 case MSAPI_AUD_DVB_AMR_NB:
7313 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7314 if (DecId == AU_DEC_ID3)
7315 HAL_AUDIO_SetDsp2CodeType(AU_DVB_NONE, TRUE);
7316 else
7317 HAL_AUDIO_SetDspCodeType(AU_DVB_NONE, TRUE);
7318 break;
7319
7320 case MSAPI_AUD_DVB_AMR_WB:
7321 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7322 if (DecId == AU_DEC_ID3)
7323 HAL_AUDIO_SetDsp2CodeType(AU_DVB_NONE, TRUE);
7324 else
7325 HAL_AUDIO_SetDspCodeType(AU_DVB_NONE, TRUE);
7326 break;
7327
7328
7329 case MSAPI_AUD_DVB_DolbyTrueHDBypass:
7330 HAL_AUR2_WriteByte(regDecoderType, adec_type_dolby_truhd_bypass); /* select r2 decoder to olby TrueHD bypss */
7331 if (DecId == AU_DEC_ID3)
7332 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DolbyTrueHD_Bypass,TRUE); //set decoder type for HDMI Tx handler
7333 else
7334 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DolbyTrueHD_Bypass,TRUE); //set decoder type for HDMI Tx handler
7335 break;
7336
7337 case MSAPI_AUD_DVB_DTSHDADO:
7338 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7339 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7340 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7341 if (DecId == AU_DEC_ID3)
7342 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7343 else
7344 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7345 break;
7346
7347 default:
7348 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, Param);
7349 if (DecId == AU_DEC_ID3)
7350 HAL_AUDIO_SetDsp2CodeType(AU_DVB_NONE, TRUE);
7351 else
7352 HAL_AUDIO_SetDspCodeType(AU_DVB_NONE, TRUE);
7353 break;
7354 }
7355
7356 return bRet;
7357 }
7358
AU_GetDecID(AUDIO_DEC_ID * DecPriority,AudioDecStatus_t * p_AudioDecStatus)7359 AUDIO_DEC_ID AU_GetDecID(AUDIO_DEC_ID *DecPriority, AudioDecStatus_t * p_AudioDecStatus)
7360 {
7361 int Index = 0;
7362 AUDIO_DEC_ID DecID = AU_DEC_INVALID;
7363
7364 for(Index=0; Index<AU_DEC_MAX; Index++)
7365 {
7366 // Get Dec ID by priority
7367 DecID = DecPriority[Index];
7368 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7369 if ((HAL_MAD_GetAudioCapability(DecID, p_AudioDecStatus) == TRUE) &&
7370 (g_AudioVars2->AudioDecStatus[DecID].bConnect == FALSE))
7371 {
7372 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7373 break;
7374 }
7375 }
7376
7377 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7378 return DecID;
7379 }
7380
HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)7381 AUDIO_DEC_ID HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)
7382 {
7383 AUDIO_DEC_ID DecRet = AU_DEC_INVALID;
7384
7385 switch (p_AudioDecStatus->eSourceType)
7386 {
7387 case E_AUDIO_INFO_ATV_IN:
7388 DecRet = AU_DEC_ID2;
7389 break;
7390
7391 case E_AUDIO_INFO_HDMI_IN:
7392 DecRet = AU_GetDecID(HDMIDecPriority, p_AudioDecStatus);
7393 break;
7394
7395 case E_AUDIO_INFO_DTV_IN:
7396 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7397 break;
7398
7399 case E_AUDIO_INFO_MM_IN:
7400 case E_AUDIO_INFO_GAME_IN:
7401 DecRet = AU_GetDecID(MMDecPriority, p_AudioDecStatus);
7402 break;
7403
7404 default:
7405 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7406 break;
7407 }
7408
7409 printf("DecID = %d %s() %d \n",DecRet,__FUNCTION__,__LINE__);
7410 return DecRet;
7411 }
7412
HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId,AudioDecStatus_t * p_AudioDecStatus)7413 MS_BOOL HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus)
7414 {
7415 AUDIO_DSP_ID DSP_id;
7416 MS_BOOL bRet = FALSE;
7417
7418 HALAUDIO_CHECK_SHM_INIT;
7419
7420 if((g_AudioVars2->AudioDecStatus[DecId].eAudFormat == p_AudioDecStatus->eAudFormat) &&
7421 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == p_AudioDecStatus->eSourceType) &&
7422 (g_AudioVars2->AudioDecStatus[DecId].eGroup == p_AudioDecStatus->eGroup) &&
7423 (g_AudioVars2->AudioDecStatus[DecId].eStcSource == p_AudioDecStatus->eStcSource) &&
7424 (g_AudioVars2->AudioDecStatus[DecId].bIsAD == p_AudioDecStatus->bIsAD))
7425 {
7426 HALAUDIO_PRINT("%s() - DSP code is the same\n",__FUNCTION__);
7427 return bRet;
7428 }
7429
7430 // update occupied decoder
7431 if (DecId == AU_DEC_ID3)
7432 {
7433 DSP_id = AUDIO_DSP_ID_SND;
7434 }
7435 else
7436 {
7437 DSP_id = AUDIO_DSP_ID_DEC;
7438 }
7439
7440 if ((p_AudioDecStatus->eAudFormat & MSAPI_AUD_ATV_NONE) == MSAPI_AUD_ATV_NONE)
7441 {
7442 AUDIO_PATH_TYPE u8SifPath;
7443 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7444 {
7445 u8SifPath = AUDIO_PATH_6;
7446 }
7447 else
7448 {
7449 u8SifPath = AUDIO_PATH_MAIN;
7450 }
7451 HAL_AUDIO_SetInputPath(AUDIO_DSP4_SIF_INPUT , u8SifPath);
7452 }
7453 else
7454 {
7455 HAL_MAD_DvbFLockSynthesizer_En();
7456 }
7457 //g_AudioVars2->AudioDecStatus[DecId].eDSPId = DSP_id;
7458 //p_AudioDecStatus->eDSPId = DSP_id;
7459
7460 switch ( p_AudioDecStatus->eAudFormat)
7461 {
7462 case MSAPI_AUD_DVB_MPEG:
7463 case MSAPI_AUD_DVB_AC3:
7464 case MSAPI_AUD_DVB_AC3P:
7465 case MSAPI_AUD_DVB_MP3:
7466 case MSAPI_AUD_DVB_AAC:
7467 case MSAPI_AUD_DVB_XPCM:
7468 case MSAPI_AUD_DVB_RA8LBR:
7469 case MSAPI_AUD_DVB_WMA:
7470 case MSAPI_AUD_DVB_DTS:
7471 case MSAPI_AUD_DVB_MS10_DDT:
7472 case MSAPI_AUD_DVB_MS10_DDC:
7473 case MSAPI_AUD_DVB_WMA_PRO:
7474 case MSAPI_AUD_DVB_FLAC:
7475 case MSAPI_AUD_DVB_VORBIS:
7476 case MSAPI_AUD_DVB_AMR_NB:
7477 case MSAPI_AUD_DVB_AMR_WB:
7478 case MSAPI_AUD_DVB_DRA:
7479 case MSAPI_AUD_DVB_DTSLBR:
7480 case MSAPI_AUD_DVB_DTSHDADO:
7481 bRet = HAL_AUDIO_SetSystem2(DecId, p_AudioDecStatus->eAudFormat);
7482 if ( bRet == TRUE )
7483 {
7484 g_AudioVars2->AudioDecStatus[DecId].eAudFormat = (En_DVB_decSystemType) p_AudioDecStatus->eAudFormat;
7485 }
7486 break;
7487
7488 case MSAPI_AUD_ATV_BTSC:
7489 bRet = HAL_SIF_SetSystem(AU_SIF_BTSC);
7490 break;
7491
7492 case MSAPI_AUD_ATV_PAL:
7493 bRet = HAL_SIF_SetSystem(AU_SIF_PALSUM);
7494 break;
7495
7496 case MSAPI_AUD_ATV_EIAJ:
7497 case MSAPI_AUD_ATV_FM_RADIO:
7498 break;
7499
7500 default:
7501 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, p_AudioDecStatus->eAudFormat);
7502 break;
7503 }
7504
7505 return bRet;
7506 }
7507
7508 ////////////////////////////////////////////////////////////////////////////////
7509 /// @brief \b Function \b Name: HAL_AUDIO_GetDDRInfo()
7510 /// @brief \b Function \b Description: Return Audio DDR info
7511 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
7512 /// @param <IN> \b EN_AUDIO_DDRINFO : DDR info
7513 /// @param <OUT> \b MS_U32 : return DDR info
7514 /// @param <RET> \b NONE :
7515 /// @param <GLOBAL> \b NONE :
7516 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId,EN_AUDIO_DDRINFO DDRInfo)7517 MS_U32 HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo)
7518 {
7519 MS_U32 DDR_ADDR = 0;
7520 MS_U32 DDR_ADDR_LINE_BASE = 0;
7521 MS_U16 DDR_ADDR_TMP;
7522 MS_U32 DDR_Value = 0;
7523 if (DecId == AU_DEC_ID1)
7524 {
7525 switch(DDRInfo)
7526 {
7527 case E_AUD_MEMORY_BASE: //use DSP2 base instead
7528 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7529 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7530 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7531 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7532 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7533 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7534 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7535 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7536 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7537 DDR_Value = DDR_ADDR;
7538 break;
7539 case E_AUD_MEMORY_SIZE:
7540 //TODO
7541 break;
7542 default:
7543 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7544 break;
7545 }
7546 }
7547 else if(DecId == AU_DEC_ID3)
7548 {
7549 switch(DDRInfo)
7550 {
7551 case E_AUD_MEMORY_BASE:
7552 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7553 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7554 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7555 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7556 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7557 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7558 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7559 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7560 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7561 DDR_Value = DDR_ADDR;
7562 break;
7563 case E_AUD_MEMORY_SIZE:
7564 //TODO
7565 break;
7566 default:
7567 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7568 break;
7569 }
7570 }
7571 else
7572 {
7573 HALAUDIO_ERROR ("%s: UN-KNOW DecId (0x%x) !!\r\n", __FUNCTION__, DecId);
7574 }
7575 return DDR_Value;
7576 }
7577
7578 ////////////////////////////////////////////////////////////////////////////////
7579 /// @brief \b Function \b Name: HAL_AUDIO_DumpDspInfo()
7580 /// @brief \b Function \b Description: Dump DSP infomation
7581 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DumpDspInfo(void)7582 void HAL_AUDIO_DumpDspInfo(void)
7583 {
7584 int tmp_H, tmp_L, tmp_M;
7585 long long result = 0;
7586 unsigned int ES_Lvl, PCM_Lvl;
7587 static MS_U32 preSysTime, prv_mmFile_APTS;
7588 MS_U32 sysTime, mmFile_APTS;
7589
7590 if(g_AudioDumpInfoCtrl == Audio_DumpInfo_Off)
7591 {
7592 return;
7593 }
7594
7595 ES_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
7596 PCM_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC1);
7597
7598 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Avsync) != 0)
7599 {
7600 sysTime = MsOS_GetSystemTime();
7601 printf("[%08d]", sysTime);
7602
7603 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7604 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
7605
7606 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFFFF;
7607 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFF;
7608 printf("PCM=%04X(%04X,%04X)|", PCM_Lvl, tmp_H, tmp_L);
7609
7610 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7611 printf("play=%X", tmp_L);
7612
7613 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
7614 printf("<%04X>,", tmp_L);
7615
7616 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
7617 tmp_M = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, ADEC1, 0)&0x0F;
7618 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
7619 printf("State=%X,%X(%X)|", tmp_L,tmp_M, tmp_H);
7620
7621 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7622 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7623 printf("frmCnt:%04X,", tmp_L);
7624 printf("%04X,", tmp_H);
7625
7626 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7627 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7628 printf("%02X,", tmp_L);
7629 printf("%02X,", tmp_H);
7630
7631 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_1STPTS_CNT, ADEC1)&0x00FF;
7632 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_STC_CNT, ADEC1)&0x00FF;
7633 tmp_M = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_FLUSH_CNT, ADEC1)&0x00FF;
7634 printf("%02X,%02X,%02X|", tmp_L, tmp_H, tmp_M);
7635
7636 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_WR_IDX, ADEC1)&0xF;
7637 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_RD_IDX, ADEC1)&0xF;
7638 printf("tag:%01X,%01X|", tmp_L, tmp_H);
7639
7640 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_OFFSET, ADEC1)&0x00FFFFFF;
7641 printf("AvDly=%05X,", tmp_L);
7642
7643 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_STC, ADEC1);
7644 printf("STC=%08lld,", result/45);
7645
7646 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, ADEC1);
7647 printf("PTS=%08lld,", result/45);
7648
7649 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
7650 printf("cPTS=%08lld,", result/45);
7651
7652 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TD, ADEC1);
7653 printf("|Td=%lld\n", result/90);
7654 }
7655
7656 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Dec1) != 0)
7657 {
7658 sysTime = MsOS_GetSystemTime();
7659 printf("[%08d]", sysTime);
7660
7661 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7662 printf("ES=%03X(%04X),", ES_Lvl, tmp_L);
7663
7664 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFF;
7665 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFF;
7666 printf("PCM=%04X(%04X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
7667
7668 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_TYPE);
7669 printf("ID=%02X,", tmp_L);
7670
7671 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_TYPE, ADEC1)&0x00FF;
7672 printf("Type=%02X,", tmp_L);
7673
7674 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFFFF;
7675 printf("pState=%06X,", tmp_L);
7676
7677 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7678 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
7679 printf("|Cmd=%02X,Stop=%02X|", tmp_L, tmp_H);
7680
7681 tmp_L = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER1_CFG);
7682 tmp_H = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER2_CFG);
7683 printf("Input_Mux:%02X,", tmp_L&0x7);
7684 printf("%02X,", tmp_H&0x7);
7685 printf("%02X|", (tmp_L>>16)&0x7);
7686
7687 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7688 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7689 printf("frmCnt:%04X,", tmp_L);
7690 printf("%04X,", tmp_H);
7691
7692 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7693 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7694 printf("%02X,", tmp_L);
7695 printf("%02X|", tmp_H);
7696
7697 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FFFF;
7698 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x0000FFFF;
7699 printf("Call:%04X,", tmp_L);
7700 printf("sMiss:%04X|", tmp_H);
7701
7702 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC1)&0x00FFFFFF;
7703 printf("pcm=%06X,", tmp_L);
7704
7705 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_R, ADEC1)&0x00FFFFFF;
7706 printf("%06X|", tmp_L);
7707
7708 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7709 printf("play=%X\n", tmp_L);
7710 }
7711
7712
7713 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_IoInfo) != 0)
7714 {
7715 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH5_CFG)) & 0x000F;
7716 printf("CH5 mux=0x%02X,", tmp_L);
7717
7718 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH6_CFG)) & 0x000F;
7719 printf("Ch6 mux=0x%02X,", tmp_L);
7720
7721 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH7_CFG)) & 0x000F;
7722 printf("Ch7 mux=0x%02X", tmp_L);
7723
7724 // Not define
7725 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC1)&0x00FFFFFF;
7726 printf("|DEC1=0x%06X,", tmp_L);
7727
7728 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_OUT_L, ADEC2)&0x00FFFFFF;
7729 printf("DEC2=0x%06X", tmp_L);
7730
7731 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_RAW+0, DSP_MEM_TYPE_DM);
7732 printf("|CH5=0x%06X,", tmp_L);
7733
7734 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_MUL_CH6+0, DSP_MEM_TYPE_DM);
7735 printf("CH6=0x%06X,", tmp_L);
7736
7737 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_SCART+0, DSP_MEM_TYPE_DM);
7738 printf("CH7=0x%06X", tmp_L);
7739
7740 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_DAC1_OUT+0, DSP_MEM_TYPE_DM);
7741 printf("|DAC1=0x%06X,", tmp_L);
7742
7743 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_IIS1_OUT+0, DSP_MEM_TYPE_DM);
7744 printf("I2S=0x%06X,", tmp_L);
7745
7746 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_SPDIF_OUT+0, DSP_MEM_TYPE_DM);
7747 printf("SPDIF=0x%06X\n", tmp_L);
7748 }
7749
7750 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_AutoTest) != 0)
7751 {
7752 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x00FFFFFF;
7753 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x00FFFFFF;
7754 printf("[AutoTest][AUDIO][FrameCount][%d]\n", tmp_L);
7755 printf("[AutoTest][AUDIO][ErrorCount][%d]\n", tmp_H);
7756
7757 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
7758 printf("[AutoTest][AUDIO][SampleRate][%d]\n", tmp_L);
7759 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
7760 printf("[AutoTest][AUDIO][ACMod][%d]\n", tmp_L);
7761 }
7762
7763 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_mmFileAVsync) != 0)
7764 {
7765 sysTime = MsOS_GetSystemTime();
7766 printf("[%08d](%03d):", sysTime, sysTime - preSysTime);
7767 preSysTime = sysTime;
7768
7769 mmFile_APTS = HAL_MAD_GetCommInfo(Audio_Comm_infoType_1ms_PTS);
7770 printf("APTS:%07d(%03d)|", mmFile_APTS, mmFile_APTS - prv_mmFile_APTS);
7771 prv_mmFile_APTS = mmFile_APTS;
7772
7773 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1)&0xFFFF;
7774 printf("MM:%04X|", tmp_H);
7775
7776 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7777 printf("ES=%04X(%04X),", ES_Lvl, tmp_L);
7778
7779 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCMISR_EMPTY_CNT, ADEC1)&0xFF;
7780 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ELAPSED_PCM_CNT, ADEC1)&0xFFFFFF;
7781 printf("PCM=%04X(%06X,%02X)|", PCM_Lvl, tmp_H, tmp_L);
7782
7783 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7784 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
7785 printf("Cmd=%02X,Stop=%02X,", tmp_L, tmp_H);
7786
7787 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7788 printf("play=%X", tmp_L);
7789
7790 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
7791 printf("<%04X>,", tmp_L);
7792
7793 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
7794 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
7795 printf("State=%X(%X)|", tmp_L, tmp_H);
7796
7797 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7798 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7799 printf("frmCnt:%04X,", tmp_L);
7800 printf("%04X,", tmp_H);
7801
7802 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7803 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7804 printf("%02X,", tmp_L);
7805 printf("%02X|", tmp_H);
7806
7807 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_ID, DSP_MEM_TYPE_DM)&0x00FF;
7808 //printf("DEC_ID=%02X,", tmp_L);
7809
7810 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_DEC_TYPE, DSP_MEM_TYPE_DM)&0x00FF;
7811 //printf("Type=%02X,", tmp_L);
7812
7813 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFF;
7814 printf("pState=%04X,", tmp_L);
7815
7816 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FF;
7817 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x00000FFF;
7818 printf("Call:%02X,", tmp_L);
7819 printf("Miss:%03X\n", tmp_H);
7820 }
7821
7822 }
7823
7824
7825 #ifndef MSOS_TYPE_NUTTX
HAL_AUDIO_ResetTeeInfoShmToDefault(void)7826 MS_BOOL HAL_AUDIO_ResetTeeInfoShmToDefault(void)
7827 {
7828 if (pAudioTeeInfoShm == NULL)
7829 {
7830 return FALSE;
7831 }
7832 memset(pAudioTeeInfoShm, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
7833 audio_tee_enabled = g_bAudioTeeEnabled;
7834 audio_tee_mbx_initialized = g_bAudioTeeMbxInitialized;
7835 dec_dsp_secure_tee_accessed = g_bDecDspSecureTeeAccessed;
7836 snd_dsp_secure_tee_accessed = g_bSndDspSecureTeeAccessed;
7837 return TRUE;
7838 }
7839
HAL_AUDIO_AllocateTeeInfoShm(void)7840 AUDIO_TEE_INFO_SHARE_MEM *HAL_AUDIO_AllocateTeeInfoShm(void)
7841 {
7842 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7843 MS_U32 u32ShmId = 0;
7844 AUDIO_TEE_INFO_SHARE_MEM * virtAddr = 0;
7845 MS_U32 u32BufSize = 0;
7846
7847 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)
7848 {
7849 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7850
7851 if (pAudioTeeInfoShm->g_u32ClientCounter == 0)
7852 {
7853 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7854 HAL_AUDIO_ResetTeeInfoShmToDefault();
7855 }
7856 }
7857 else
7858 {
7859 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)
7860 {
7861 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7862 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7863
7864 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7865 HAL_AUDIO_ResetTeeInfoShmToDefault();
7866 }
7867 else
7868 {
7869 HALAUDIO_ERROR("SHM allocation for Audio TEE Info failed!\n");
7870 return NULL;
7871 }
7872 }
7873
7874 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7875 {
7876 g_bAudioTeeInfoShmInitFlag = TRUE;
7877 pAudioTeeInfoShm->g_u32ClientCounter++;
7878 }
7879 #else
7880 pAudioTeeInfoShm = &gAudioTeeInfoShm;
7881
7882 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7883 {
7884 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7885 g_bAudioTeeInfoShmInitFlag = TRUE;
7886
7887 HAL_AUDIO_ResetTeeInfoShmToDefault();
7888 pAudioTeeInfoShm->g_u32ClientCounter++;
7889 }
7890 #endif
7891 return pAudioTeeInfoShm;
7892 }
7893
HAL_AUDIO_DeAllocateTeeInfoShm(void)7894 MS_BOOL HAL_AUDIO_DeAllocateTeeInfoShm(void)
7895 {
7896 AUDIO_TEE_INFO_SHARE_MEM * pAUDIOShared = NULL;
7897
7898 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7899 MS_U32 u32ShmId = 0;
7900 MS_VIRT virtAddr = 0;
7901 MS_U32 u32BufSize = 0;
7902
7903 if (g_bAudioTeeInfoShmInitFlag == TRUE)
7904 {
7905 g_bAudioTeeInfoShmInitFlag = FALSE;
7906
7907 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) == FALSE)
7908 {
7909 HALAUDIO_ERROR("%s() : No AUDIO TEE Info SHM is created!\n", __FUNCTION__);
7910 return FALSE;
7911 }
7912
7913 pAUDIOShared = (AUDIO_TEE_INFO_SHARE_MEM *)virtAddr;
7914 pAUDIOShared->g_u32ClientCounter--;
7915
7916 if (pAUDIOShared->g_u32ClientCounter == 0)
7917 {
7918 printf("free Audio TEE Info SHM data ...\n");
7919 #if defined(MSOS_TYPE_LINUX)
7920 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, u32ShmId) == TRUE)
7921 {
7922 HALAUDIO_PRINT("Audio TEE Info SHM data is freed\n");
7923 }
7924 else
7925 {
7926 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
7927 return FALSE;
7928 }
7929 #endif
7930 }
7931 }
7932 #else
7933 pAUDIOShared = &gAudioTeeInfoShm;
7934
7935 if (g_bAudioTeeInfoShmInitFlag == TRUE)
7936 {
7937 HALAUDIO_PRINT("free Audio TEE Info SHM data ...\n");
7938 g_bAudioTeeInfoShmInitFlag = FALSE;
7939
7940 memset(pAUDIOShared, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
7941 }
7942 #endif
7943
7944 return TRUE;
7945 }
7946
HAL_AUDIO_RegisterMBX(void)7947 MS_BOOL HAL_AUDIO_RegisterMBX(void)
7948 {
7949 MS_U8 ClassNum=0;
7950 MBX_Result result;
7951 MBX_CPU_ID eHKCPU;
7952 MS_U32 u32TimeoutMillSecs = 10000;
7953
7954 if (pAudioTeeInfoShm == NULL)
7955 return FALSE;
7956 if (audio_tee_mbx_initialized == TRUE)
7957 return TRUE;
7958
7959 #if 1
7960 eHKCPU = E_MBX_CPU_MIPS;
7961 if ( E_MBX_SUCCESS != MApi_MBX_Init(eHKCPU, E_MBX_ROLE_HK, u32TimeoutMillSecs))
7962 {
7963 DBG_AUDIO_ERROR("Error> MBX init failed !!\n");
7964 return FALSE;
7965 }
7966 else
7967 {
7968 MApi_MBX_Enable(TRUE);
7969 }
7970 #endif
7971
7972 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass (E_MBX_CPU_MIPS_VPE1, "MAD", (MS_U8 *)&ClassNum))
7973 {
7974 DBG_AUDIO_ERROR("MAD MApi_MBX_QueryDynamicClass fail\n");
7975
7976 return FALSE;
7977 }
7978 result = MApi_MBX_RegisterMSG(ClassNum, 10);
7979 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
7980 {
7981 DBG_AUDIO_ERROR("HAL_AUDIO_RegisterMBX fail");
7982 return FALSE;
7983 }
7984 else
7985 {
7986 TEE_MBX_MSG_CLASS_SET(ClassNum);
7987 DBG_AUDIO("HAL_AUDIO_RegisterMBX ok");
7988 return TRUE;
7989 }
7990 }
7991
HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)7992 TEE_TO_REE_MBX_ACK_MSG_TYPE HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)
7993 {
7994 MS_U8 u8Index;
7995 MBX_Result result;
7996 REE_TO_TEE_MBX_MSG_TYPE msg_type1 = REE_TO_TEE_MBX_MSG_NULL;
7997
7998 AUDIO_TEE_INFO_SHM_CHECK_NULL;
7999
8000 if (audio_tee_enabled == FALSE)
8001 {
8002 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8003 }
8004 if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_DEC) == (REE_TO_TEE_MBX_MSG_TYPE_DEC))
8005 {
8006 if (dec_dsp_secure_tee_accessed == FALSE)
8007 {
8008 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8009 }
8010 else
8011 {
8012 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_DEC);
8013 }
8014 }
8015 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_SE) == (REE_TO_TEE_MBX_MSG_TYPE_SE))
8016 {
8017 if (snd_dsp_secure_tee_accessed == FALSE)
8018 {
8019 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
8020 }
8021 else
8022 {
8023 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_SE);
8024 }
8025 }
8026 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_GENERAL) == (REE_TO_TEE_MBX_MSG_TYPE_GENERAL))
8027 {
8028
8029 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
8030 }
8031
8032 if (audio_tee_mbx_initialized == FALSE)
8033 {
8034 return TEE_TO_REE_MBX_ACK_MSG_INVALID;
8035 }
8036 REE_TO_TEE_MBX_MSG_INIT;
8037 MBX_MSG_SET_CLASSID(ree_to_tee_mbx_msg, tee_mbx_msg_class);
8038 MBX_MSG_SET_CMD(ree_to_tee_mbx_msg, msg_type1);
8039
8040 result = MApi_MBX_SendMsg(&(ree_to_tee_mbx_msg));
8041 if (E_MBX_SUCCESS!= result)
8042 {
8043 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8044 }
8045 // Receive Reply ACK from TEE side.
8046 memset(&(tee_to_ree_mbx_msg), 0, sizeof(MBX_Msg));
8047 MBX_MSG_SET_CLASSID(tee_to_ree_mbx_msg, tee_mbx_msg_class);
8048 do
8049 {
8050 result = MApi_MBX_RecvMsg(tee_mbx_msg_class, &(tee_to_ree_mbx_msg), 2000, MBX_CHECK_INSTANT_MSG);
8051 } while(E_MBX_SUCCESS != result);
8052
8053 u8Index = tee_to_ree_mbx_msg.u8Index;
8054 DBG_AUDIO("Recv TEE Ack Msg OK cmd:%x\n", u8Index);
8055
8056 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL == u8Index)
8057 {
8058 DBG_AUDIO_ERROR("RecvMsg TEE_TO_REE_MBX_MSG_ACK_FAIL..\n");
8059 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
8060 }
8061 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS == u8Index)
8062 {
8063 DBG_AUDIO("RecvMsg TEE_TO_REE_MBX_MSG_ACK_SUCCESS..\n");
8064 }
8065
8066 return TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
8067 }
8068 #else
_MAD_Proc(void)8069 static void _MAD_Proc(void)
8070 {
8071 MS_U32 u32Events;
8072 MS_U8 u8Index = 0;
8073 MBX_Result result;
8074
8075 DBG_AUDIO("_MAD_Proc...........\n");
8076
8077 while (1)
8078 {
8079 MsOS_WaitEvent(_s32MadEventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
8080 u8Index = msg.u8Index;
8081
8082 memset(&TeeToReeMbxAckMsg, 0, sizeof(MBX_Msg));
8083 TEE_TO_REE_MBX_MSG_INIT(TeeToReeMbxAckMsg);
8084 MBX_MSG_SET_CLASSID(TeeToReeMbxAckMsg, msg.u8MsgClass);
8085 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS);
8086
8087 switch ( u8Index )
8088 {
8089 case REE_TO_TEE_MBX_MSG_HAL_AUDSP_DspLoadCode:
8090 {
8091 AUDIO_DSP_CODE_TYPE dspCodeType;
8092 dspCodeType = (msg.u8Parameters[0] || (msg.u8Parameters[1] << 8));
8093 if (HAL_AUDSP_DspLoadCode((AUDIO_DSP_CODE_TYPE)dspCodeType) == FALSE)
8094 {
8095 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8096 }
8097 break;
8098 }
8099
8100 case REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr:
8101 {
8102 MS_U32 u32Bin_Base_Address, u32Mad_Base_Buffer_Adr;
8103 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));
8104 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));
8105 HAL_AUDIO_SetDspBaseAddr(msg.u8Parameters[0], u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
8106 break;
8107 }
8108
8109 default:
8110 {
8111 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
8112 break;
8113 }
8114 }
8115
8116 result = MApi_MBX_SendMsg(&TeeToReeMbxAckMsg);
8117 if (E_MBX_SUCCESS != result)
8118 DBG_AUDIO("MAD Reply Ack fail classid: %x cmd:%x \n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8119 else
8120 DBG_AUDIO("MAD Reply Ack ok classid:%x cmd:%x\n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
8121 }
8122 }
8123
HAL_AUDIO_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)8124 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
8125 {
8126 if(pMsg==NULL)
8127 {
8128 DBG_AUDIO("pMsg is a null pointer\n");
8129 return;
8130 }
8131 if (_s32MadEventId < 0)
8132 {
8133 DBG_AUDIO("MAD EventGroup Id is not valid...\n");
8134 return;
8135 }
8136 memcpy(&msg, pMsg, sizeof(MBX_Msg));
8137 MsOS_SetEvent(_s32MadEventId, 1);
8138 return;
8139 }
8140 #endif
8141
8142 ////////////////////////////////////////////////////////////////////////////////
8143 /// @brief \b Function \b Name: HAL_AUDIO_update_DspUsage()
8144 /// @brief \b Function \b Description: update DSP resource status when select input source
8145 /// @param <IN> \b AUDIO_SOURCE_INFO_TYPE : select input source type
8146 /// @param <OUT> \b NONE :
8147 /// @param <RET> \b NONE :
8148 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)8149 void HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)
8150 {
8151 HALAUDIO_CHECK_SHM_INIT;
8152
8153 /* same input source, not update */
8154 if ( g_AudioVars2->eMainSourceType == eSourceType )
8155 {
8156 return;
8157 }
8158
8159 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
8160
8161 HALAUDIO_PRINT ("%s: PrevSource %d NowSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType, eSourceType);
8162
8163 /* release prev DSP resource */
8164 if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN && eSourceType != E_AUDIO_INFO_DTV_IN) )
8165 {
8166 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = FALSE;
8167 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8168 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_NONE;
8169 HALAUDIO_PRINT ("%s: Release DEC DSP from DTV !!\r\n", __FUNCTION__);
8170 }
8171 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN && eSourceType != E_AUDIO_INFO_ATV_IN) )
8172 {
8173 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8174 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8175 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8176 HALAUDIO_PRINT ("%s: Release SND DSP from ATV !!\r\n", __FUNCTION__);
8177 }
8178 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN && eSourceType != E_AUDIO_INFO_HDMI_IN) )
8179 {
8180 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
8181 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8182 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
8183 HALAUDIO_PRINT ("%s: Release SND DSP from HDMI !!\r\n", __FUNCTION__);
8184 }
8185
8186 g_AudioVars2->ePrevSourceType = g_AudioVars2->eMainSourceType;
8187 g_AudioVars2->eMainSourceType = eSourceType;
8188
8189 /* lock main input source DSP resource */
8190 if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN )
8191 {
8192 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = TRUE;
8193 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
8194 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_DTV;
8195 HALAUDIO_PRINT ("%s: Alloc DEC DSP for DTV !!\r\n", __FUNCTION__);
8196 }
8197 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN )
8198 {
8199 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8200 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8201 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_ATV;
8202 HALAUDIO_PRINT ("%s: Alloc DEC DSP for ATV !!\r\n", __FUNCTION__);
8203 }
8204 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN )
8205 {
8206 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
8207 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
8208 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_HDMI;
8209 HALAUDIO_PRINT ("%s: Alloc DEC DSP for HDMI !!\r\n", __FUNCTION__);
8210 }
8211
8212 HALAUDIO_PRINT ("%s: update PrevSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType);
8213
8214 OS_RELEASE_MUTEX(_s32MutexLoadCode);
8215 }
8216
HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id)8217 Audio_id HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id) //temp
8218 {
8219 Audio_id ADEC_id;
8220 switch(dec_id)
8221 {
8222 case AU_DEC_INVALID:
8223 case AU_DEC_MAX:
8224 printf("[Error] Can't convert...\n");
8225 ADEC_id = ADEC3; //no usage just take one for it...
8226 break;
8227
8228 case AU_DEC_ID1:
8229 ADEC_id = ADEC1;
8230 break;
8231
8232 case AU_DEC_ID2:
8233 case AU_DEC_ID3:
8234 ADEC_id = ADEC2;
8235 break;
8236
8237 default:
8238 ADEC_id = ADEC3;
8239 break;
8240 }
8241 return ADEC_id;
8242 }
8243
8244 ////////////////////////////////////////////////////////////////////////////////
8245 /// @brief \b Function \b Name: HAL_AUDIO_GetCaps()
8246 /// @brief \b Function \b Description: Get Audio Capabilities
8247 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
8248 /// @param <IN> \b MS_U32 * : Audio Capabilites pointer
8249 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
8250 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId,MS_U32 * pCaps)8251 MS_U32 HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId, MS_U32 *pCaps)
8252 {
8253 AUDIO_CAPABILITIES *pCapsTmp = NULL;
8254 MS_U32 u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
8255
8256 HALAUDIO_CHECK_SHM_INIT;
8257
8258 if (pCaps == NULL)
8259 {
8260 HALAUDIO_ERROR("%s: Error! pCaps should not be NULL!\n", __FUNCTION__);
8261 return FALSE;
8262 }
8263
8264 if ((DecId <= AU_DEC_INVALID) || (DecId >= AU_DEC_MAX) || (DecId == AU_DEC_ID2))
8265 {
8266 HALAUDIO_ERROR("%s: Error! Invalid DecId (%d)!\n", __FUNCTION__, DecId);
8267 return FALSE;
8268 }
8269 else if ((g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum == 1) && (DecId > AU_DEC_ID1))
8270 {
8271 HALAUDIO_ERROR("%s: Error! DecId (%d) is greater than max decoder number (%d)!\n", __FUNCTION__, DecId, g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum);
8272 return FALSE;
8273 }
8274
8275 pCapsTmp = (AUDIO_CAPABILITIES *)pCaps;
8276
8277 if (pCapsTmp->u32AudioCapsVersion == 0)
8278 {
8279 HALAUDIO_ERROR("%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsVersion);
8280 return FALSE;
8281 }
8282
8283 if (pCapsTmp->u32AudioCapsStructSize == 0)
8284 {
8285 HALAUDIO_ERROR("%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, pCapsTmp->u32AudioCapsStructSize);
8286 return FALSE;
8287 }
8288
8289 if (pCapsTmp->u32AudioCapsVersion != g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion)
8290 {
8291 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);
8292
8293 u32AudioCapsStructSize = (u32AudioCapsStructSize <= pCapsTmp->u32AudioCapsStructSize) ? u32AudioCapsStructSize : pCapsTmp->u32AudioCapsStructSize;
8294 }
8295
8296 memcpy((void *)pCapsTmp, (void *)&g_AudioVars2->AudioCaps[DecId], u32AudioCapsStructSize);
8297
8298 return TRUE;
8299 }
8300
8301 ////////////////////////////////////////////////////////////////////////////////
8302 /// @brief \b Function \b Name: HAL_AUDIO_Set_DecimationMode()
8303 /// @brief \b Function \b Description: HAL_AUDIO_Set_Decimation register
8304 /// @param <IN> \b AUDIO_OUTPUT_TYPE Output_Type: Audio Output type
8305 /// @param <IN> \b MS_BOOL Enable : Audio ID: ADEC ID
8306 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type,Audio_id ID)8307 void HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type, Audio_id ID)
8308 {
8309 switch(Output_Type)
8310 {
8311 case AUDIO_HDMI_OUTPUT: //high rate nonPCM application need decimation
8312 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL+1)&0x20))
8313 {
8314 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x04);
8315 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x10);
8316 }
8317 else
8318 {
8319 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x00);
8320 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x00);
8321 }
8322 break;
8323
8324 case AUDIO_HDMI_ARC_OUTPUT:
8325 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8326 {
8327 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x02);
8328 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x08);
8329 }
8330 else
8331 {
8332 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x00);
8333 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x00);
8334 }
8335 break;
8336
8337 case AUDIO_SPDIF_OUTPUT:
8338 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8339 {
8340 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x01);
8341 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x04);
8342 }
8343 else
8344 {
8345 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x00);
8346 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x00);
8347 }
8348 break;
8349
8350 default:
8351 break;
8352 }
8353 }
8354
8355 ////////////////////////////////////////////////////////////////////////////////
8356 /// @brief \b Function \b Name: HAL_AUDIO_CheckPlayDone()
8357 /// @brief \b Function \b Description: Check file play done. If file play done, will return TRUE
8358 /// @param <IN> \b NONE :
8359 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8360 /// @param <GLOBAL> \b NONE :
8361 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckPlayDone(void)8362 MS_BOOL HAL_AUDIO_CheckPlayDone(void)
8363 {
8364 if (((HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_okFrmCnt) !=0) ||
8365 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_errFrmCnt) !=0)) &&
8366 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_pcmBuf_currLevel) < AUD_R2_DMA_BURST_BYTES))
8367 {
8368 CheckPlayDoneCnt = CheckPlayDoneCnt + 1;
8369
8370 if (CheckPlayDoneCnt == 3)
8371 {
8372 CheckPlayDoneCnt = 0;
8373 return TRUE;
8374 }
8375 return FALSE;
8376 }
8377 else
8378 {
8379 CheckPlayDoneCnt = 0;
8380 return FALSE;
8381 }
8382 }
8383
8384 ////////////////////////////////////////////////////////////////////////////////
8385 /// @brief \b Function \b Name: HAL_AUDIO_CheckVersionInfo()
8386 /// @brief \b Function \b Description: Check Version info
8387 /// @param <IN> \b NONE :
8388 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8389 /// @param <GLOBAL> \b NONE :
8390 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckVersionInfo(void)8391 MS_BOOL HAL_AUDIO_CheckVersionInfo(void)
8392 {
8393 HALAUDIO_PRINT("\r\n \033[1;32m==========Audio DSP Version Check==================\033[0m");
8394 HALAUDIO_PRINT("\r\n \033[1;32m DSP System:0x%06X \033[0m \r\n", system_version_num);
8395
8396 return TRUE;
8397 }
8398
HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue,MS_U32 * pData)8399 MS_S32 HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue, MS_U32 *pData)
8400 {
8401 return 0;
8402 }
8403
HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue,MS_U32 * pData,MS_U32 u32Count)8404 MS_S32 HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue, MS_U32 *pData, MS_U32 u32Count)
8405 {
8406 MS_U32 u32Loop = 0;
8407 MS_S32 s32Ret = -A_EINVAL;
8408
8409 if (u32Count == 0)
8410 {
8411 return -A_EINVAL;
8412 }
8413
8414 if (pData != NULL)
8415 {
8416 for (u32Loop = 0; u32Loop < u32Count ; u32Loop++)
8417 {
8418 if (pData[u32Loop] == 0)
8419 {
8420 break;
8421 }
8422
8423 if (u32alue == pData[u32Loop])
8424 {
8425 s32Ret = 0;
8426 break;
8427 }
8428 }
8429 }
8430 else
8431 {
8432 s32Ret = -A_EFAULT;
8433 }
8434
8435 return s32Ret;
8436 }
8437
8438 #if AUDIO_HW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)8439 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)
8440 {
8441 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8442 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8443 MS_U16 u16Divisor = 0;
8444 MS_U16 u16Synthrate = 0;
8445 MS_U32 u32TargetBufferSize = 0;
8446 MS_U32 u32TargetChannel = 0;
8447 MS_U32 u32TargetBitWidth = 0;
8448 MS_U32 u32TargetAlignmentSize = 0;
8449 MS_S32 s32Ret = 0;
8450
8451 /*
8452 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
8453 */
8454 switch(pPcmInfo->u32SampleRate) {
8455 case 8000:
8456 {
8457 u16Divisor = 2;
8458 u16Synthrate = 0x6978;
8459 break;
8460 }
8461
8462 case 11025:
8463 {
8464 u16Divisor = 2;
8465 u16Synthrate = 0x4C87;
8466 break;
8467 }
8468
8469 case 12000:
8470 {
8471 u16Divisor = 2;
8472 u16Synthrate = 0x4650;
8473 break;
8474 }
8475
8476 case 16000:
8477 {
8478 u16Divisor = 1;
8479 u16Synthrate = 0x6978;
8480 break;
8481 }
8482
8483 case 22050:
8484 {
8485 u16Divisor = 1;
8486 u16Synthrate = 0x4C87;
8487 break;
8488 }
8489
8490 case 24000:
8491 {
8492 u16Divisor = 1;
8493 u16Synthrate = 0x4650;
8494 break;
8495 }
8496
8497 case 32000:
8498 {
8499 u16Divisor = 0;
8500 u16Synthrate = 0x6978;
8501 break;
8502 }
8503
8504 case 44100:
8505 {
8506 u16Divisor = 0;
8507 u16Synthrate = 0x4C87;
8508 break;
8509 }
8510
8511 case 48000:
8512 {
8513 u16Divisor = 0;
8514 u16Synthrate = 0x4650;
8515 break;
8516 }
8517
8518 default:
8519 {
8520 u16Divisor = 0;
8521 u16Synthrate = 0x4650;
8522 pPcmInfo->u32SampleRate = 48000;
8523 break;
8524 }
8525 }
8526
8527 /* enable DMA synthesizer */
8528 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG0, 0x20, 0x20);
8529
8530 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
8531 HAL_AUDIO_WriteMaskReg(REG_AUDIO_CLK_CFG6, 0x6000, (u16Divisor << 13));
8532 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_SYNTH_NF, 0xFFFF, u16Synthrate);
8533
8534 /* calculate buffer size */
8535 u32TargetChannel = 2;
8536 u32TargetBitWidth = 16;
8537 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
8538 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
8539 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
8540 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
8541 {
8542 HALAUDIO_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);
8543 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
8544 pPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
8545 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
8546 }
8547
8548 /* set buffer size */
8549 u32TargetBufferSize = u32TargetBufferSize * 2; /* for HW DMA Reader specification */
8550 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_3, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
8551
8552 /* set overrun & underrun threshold */
8553 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_4, 0xFFFF, u32TargetBufferSize - 12);
8554 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_5, 0xFFFF, 0x0012);
8555
8556 pPCM->u8SettingChangeFlag = FALSE;
8557
8558 return s32Ret;
8559 }
8560
HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)8561 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)
8562 {
8563 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8564 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8565 MS_S32 s32Ret = 0;
8566
8567 if (pPcmInfo->u8ConnectFlag == FALSE)
8568 {
8569 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8570 return -A_EPERM;
8571 }
8572
8573 /* clear PCM buffer */
8574 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
8575
8576 /* flush MIU */
8577 MsOS_FlushMemory();
8578
8579 /* clear engine's write pointer */
8580 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, 0x0000);
8581
8582 /* reset & start engine */
8583 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x6402);
8584 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x2402);
8585
8586 /* reset write pointer */
8587 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
8588
8589 /* reset remain size */
8590 pPCM->tPcmBufferInfo.u32RemainSize = 0;
8591
8592 return s32Ret;
8593 }
8594
HAL_AUDIO_PCM_HwDma_Reader1_Open(void * pData)8595 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Open(void *pData)
8596 {
8597 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8598 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8599 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
8600 MS_U32 u32TargetBufferAddrPa = 0;
8601 MS_U32 u32TargetBufferSize = 0;
8602 MS_U32 u32TargetChannel = 0;
8603 MS_U32 u32TargetBitWidth = 0;
8604 MS_U32 u32TargetAlignmentSize = 0;
8605 MS_S32 s32Ret = 0;
8606 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
8607
8608 if (pData == NULL)
8609 {
8610 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
8611 return -A_EFAULT;
8612 }
8613
8614 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
8615
8616 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
8617 {
8618 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
8619 return -A_EINVAL;
8620 }
8621
8622 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
8623 {
8624 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
8625 return -A_EINVAL;
8626 }
8627
8628 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8629 {
8630 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8631 return -A_EINVAL;
8632 }
8633
8634 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8635 {
8636 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
8637 return -A_EINVAL;
8638 }
8639
8640 if (pUserPcmInfo->u8CaptureFlag == TRUE)
8641 {
8642 HALAUDIO_ERROR("%s: Error! Not support capture mode!\n", __FUNCTION__);
8643 return -A_EINVAL;
8644 }
8645
8646 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)
8647 {
8648 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
8649 return -A_EINVAL;
8650 }
8651
8652 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)
8653 {
8654 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
8655 return -A_EINVAL;
8656 }
8657
8658 /* calculate buffer size */
8659 u32TargetChannel = 2;
8660 u32TargetBitWidth = 16;
8661 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
8662 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
8663 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
8664 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
8665 {
8666 HALAUDIO_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);
8667 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
8668 pUserPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
8669 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
8670 }
8671
8672 /* fill in settings */
8673 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8674 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
8675 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
8676 pPcmInfo->u8ConnectFlag = TRUE;
8677 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
8678 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
8679 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
8680 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
8681 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
8682 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
8683 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
8684 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
8685 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
8686 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
8687 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
8688 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
8689
8690 /* init PCM buffer address */
8691 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR;
8692 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
8693 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
8694 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
8695
8696 /* set PCM buffer address */
8697 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DMA_RD_CTRL_7, 0xFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFF)); /* RD_BASE_ADDR[7:0] */
8698 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_2, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 8) & 0xFFFF)); /* RD_BASE_ADDR[23:8] */
8699 HAL_AUDIO_WriteMaskByte((REG_AUDIO_DMA_RD_CTRL_7 + 1), 0x0F, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 24) & 0x0F)); /* RD_BASE_ADDR[27:24] */
8700
8701 /* set SEL_CLK_DMA_READER */
8702 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG6, 0x07, 0x04);
8703
8704 /* apply setting */
8705 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
8706
8707 /* restart */
8708 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
8709
8710 /* TODO : force channel8 to HW DMA Reader1, it's a hardcode */
8711 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04);
8712 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F);
8713
8714 return s32Ret;
8715 }
8716
HAL_AUDIO_PCM_HwDma_Reader1_Close(void)8717 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Close(void)
8718 {
8719 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8720 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8721 MS_S32 s32Ret = 0;
8722 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
8723
8724 if (pPcmInfo->u8ConnectFlag != FALSE)
8725 {
8726 HAL_AUDIO_PCM_HwDma_Reader1_Flush();
8727 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8728 }
8729
8730 return s32Ret;
8731 }
8732
HAL_AUDIO_PCM_HwDma_Reader1_Start(void)8733 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Start(void)
8734 {
8735 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8736 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8737 MS_S32 s32Ret = 0;
8738 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
8739
8740 if (pPcmInfo->u8StartFlag == FALSE)
8741 {
8742 if (pPCM->u8SettingChangeFlag == TRUE)
8743 {
8744 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
8745 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
8746 }
8747
8748 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0001);
8749 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0100);
8750
8751 pPcmInfo->u8StartFlag = TRUE;
8752 }
8753
8754 return s32Ret;
8755 }
8756
HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)8757 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)
8758 {
8759 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8760 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8761 MS_S32 s32Ret = 0;
8762 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
8763
8764 if (pPcmInfo->u8StartFlag != FALSE)
8765 {
8766 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0000);
8767 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0000);
8768
8769 pPcmInfo->u8StartFlag = FALSE;
8770 }
8771
8772 return s32Ret;
8773 }
8774
HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)8775 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
8776 {
8777 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8778 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
8779 MS_S32 s32Ret = 0;
8780 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
8781
8782 if (pData == NULL)
8783 {
8784 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
8785 return -A_EFAULT;
8786 }
8787
8788 if (pPcmInfo->u8ConnectFlag == FALSE)
8789 {
8790 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8791 return -A_EPERM;
8792 }
8793
8794 switch(u32Cmd)
8795 {
8796 case AUDIO_PCM_CMD_NONBLOCKING:
8797 {
8798 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
8799
8800 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
8801 {
8802 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
8803 s32Ret = -A_EINVAL;
8804 break;
8805 }
8806
8807 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
8808
8809 break;
8810 }
8811
8812 case AUDIO_PCM_CMD_MULTICH:
8813 {
8814 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
8815
8816 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
8817 {
8818 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
8819 s32Ret = -A_EINVAL;
8820 break;
8821 }
8822
8823 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8824 {
8825 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8826 s32Ret = -A_EINVAL;
8827 break;
8828 }
8829
8830 pPcmInfo->u8MultiChFlag = FALSE;
8831
8832 break;
8833 }
8834
8835 case AUDIO_PCM_CMD_MIXING:
8836 {
8837 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
8838
8839 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
8840 {
8841 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
8842 s32Ret = -A_EINVAL;
8843 break;
8844 }
8845
8846 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8847 {
8848 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
8849 s32Ret = -A_EINVAL;
8850 break;
8851 }
8852
8853 pPcmInfo->u8MixingFlag = FALSE;
8854
8855 break;
8856 }
8857
8858 case AUDIO_PCM_CMD_MIXINGGROUP:
8859 {
8860 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
8861
8862 pPcmInfo->u32MixingGroup = u32MixingGroup;
8863
8864 break;
8865 }
8866
8867 case AUDIO_PCM_CMD_BUFFERDURATION:
8868 {
8869 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
8870
8871 if (u32BufferDuration == 0)
8872 {
8873 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
8874 s32Ret = -A_EINVAL;
8875 break;
8876 }
8877
8878 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
8879 {
8880 pPcmInfo->u32BufferDuration = u32BufferDuration;
8881 pPCM->u8SettingChangeFlag = TRUE;
8882 }
8883
8884 break;
8885 }
8886
8887 case AUDIO_PCM_CMD_CHANNEL:
8888 {
8889 MS_U32 u32Channel = *((MS_U32 *)pData);
8890
8891 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
8892 {
8893 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
8894 return -A_EINVAL;
8895 }
8896
8897 pPcmInfo->u32Channel = u32Channel;
8898
8899 break;
8900 }
8901
8902 case AUDIO_PCM_CMD_SAMPLERATE:
8903 {
8904 MS_U32 u32SampleRate = *((MS_U32 *)pData);
8905
8906 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
8907 {
8908 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
8909 return -A_EINVAL;
8910 }
8911
8912 if (pPcmInfo->u32SampleRate != u32SampleRate)
8913 {
8914 pPcmInfo->u32SampleRate = u32SampleRate;
8915 pPCM->u8SettingChangeFlag = TRUE;
8916 }
8917
8918 break;
8919 }
8920
8921 case AUDIO_PCM_CMD_BITWIDTH:
8922 {
8923 MS_U32 u32BitWidth = *((MS_U32 *)pData);
8924
8925 pPcmInfo->u32BitWidth = u32BitWidth;
8926
8927 break;
8928 }
8929
8930 case AUDIO_PCM_CMD_BIGENDIAN:
8931 {
8932 MS_U32 u32BigEndian = *((MS_U32 *)pData);
8933
8934 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
8935 {
8936 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
8937 return -A_EINVAL;
8938 }
8939
8940 pPcmInfo->u32BigEndian = u32BigEndian;
8941
8942 break;
8943 }
8944
8945 case AUDIO_PCM_CMD_TIMESTAMP:
8946 {
8947 MS_U32 u32Timestamp = *((MS_U32 *)pData);
8948
8949 pPcmInfo->u32Timestamp = u32Timestamp;
8950
8951 break;
8952 }
8953
8954 case AUDIO_PCM_CMD_WEIGHTING:
8955 {
8956 MS_U32 u32Weighting = *((MS_U32 *)pData);
8957
8958 if (u32Weighting > 100)
8959 {
8960 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
8961 return -A_EINVAL;
8962 }
8963
8964 pPcmInfo->u32Weighting = u32Weighting;
8965
8966 break;
8967 }
8968
8969 case AUDIO_PCM_CMD_VOLUME:
8970 {
8971 MS_U32 u32Volume = *((MS_U32 *)pData);
8972
8973 if (u32Volume > 100)
8974 {
8975 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
8976 return -A_EINVAL;
8977 }
8978
8979 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
8980
8981 break;
8982 }
8983
8984 case AUDIO_PCM_CMD_MUTE:
8985 {
8986 MS_U32 u32Mute = *((MS_U32*)pData);
8987
8988 if (u32Mute == TRUE)
8989 {
8990 pPcmInfo->u32Volume |= 0x80000000;
8991 }
8992 else if (u32Mute == FALSE)
8993 {
8994 pPcmInfo->u32Volume &= 0x7FFFFFFF;
8995 }
8996 else
8997 {
8998 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
8999 s32Ret = -A_EINVAL;
9000 }
9001 break;
9002 }
9003
9004 default:
9005 {
9006 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9007 break;
9008 }
9009 }
9010
9011 return s32Ret;
9012 }
9013
HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)9014 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
9015 {
9016 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9017 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9018 MS_S32 s32Ret = 0;
9019 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9020
9021 if (pData == NULL)
9022 {
9023 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9024 return -A_EFAULT;
9025 }
9026
9027 if (pPcmInfo->u8ConnectFlag == FALSE)
9028 {
9029 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9030 return -A_EPERM;
9031 }
9032
9033 switch(u32Cmd)
9034 {
9035 case AUDIO_PCM_CMD_ALL:
9036 {
9037 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9038 MS_U32 u32MinSize = 0;
9039
9040 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9041 {
9042 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9043 s32Ret = -A_EINVAL;
9044 break;
9045 }
9046 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
9047 {
9048 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9049 }
9050
9051 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
9052 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
9053 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
9054
9055 break;
9056 }
9057
9058 case AUDIO_PCM_CMD_NONBLOCKING:
9059 {
9060 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9061 break;
9062 }
9063
9064 case AUDIO_PCM_CMD_MULTICH:
9065 {
9066 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9067 break;
9068 }
9069
9070 case AUDIO_PCM_CMD_MIXING:
9071 {
9072 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9073 break;
9074 }
9075
9076 case AUDIO_PCM_CMD_MIXINGGROUP:
9077 {
9078 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9079 break;
9080 }
9081
9082 case AUDIO_PCM_CMD_BUFFER:
9083 {
9084 /*
9085 * TODO, need better coding
9086 *
9087 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
9088 */
9089 break;
9090 }
9091
9092 case AUDIO_PCM_CMD_BUFFERDURATION:
9093 {
9094 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9095 break;
9096 }
9097
9098 case AUDIO_PCM_CMD_READPTR:
9099 {
9100 /*
9101 * TODO, need better coding
9102 *
9103 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
9104 */
9105 break;
9106 }
9107
9108 case AUDIO_PCM_CMD_WRITEPTR:
9109 {
9110 /*
9111 * TODO, need better coding
9112 *
9113 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
9114 */
9115 break;
9116 }
9117
9118 case AUDIO_PCM_CMD_CHANNEL:
9119 {
9120 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9121 break;
9122 }
9123
9124 case AUDIO_PCM_CMD_SAMPLERATE:
9125 {
9126 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9127 break;
9128 }
9129
9130 case AUDIO_PCM_CMD_BITWIDTH:
9131 {
9132 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
9133 break;
9134 }
9135
9136 case AUDIO_PCM_CMD_BIGENDIAN:
9137 {
9138 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
9139 break;
9140 }
9141
9142 case AUDIO_PCM_CMD_TIMESTAMP:
9143 {
9144 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
9145 break;
9146 }
9147
9148 case AUDIO_PCM_CMD_WEIGHTING:
9149 {
9150 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
9151 break;
9152 }
9153
9154 case AUDIO_PCM_CMD_VOLUME:
9155 {
9156 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
9157 break;
9158 }
9159
9160 case AUDIO_PCM_CMD_BUFFERLEVEL:
9161 {
9162 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0010);
9163 pPcmInfo->u32BufferLevel = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_6) * BYTES_IN_MIU_LINE) / 2;
9164 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0000);
9165 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
9166 break;
9167 }
9168
9169 case AUDIO_PCM_CMD_MUTE:
9170 {
9171 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
9172 break;
9173 }
9174
9175 case AUDIO_PCM_CMD_BUFFERSIZE:
9176 {
9177 *((MS_U32 *)pData) = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_3) * BYTES_IN_MIU_LINE) / 2; /* return valid size */
9178 break;
9179 }
9180
9181 default:
9182 {
9183 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
9184 break;
9185 }
9186 }
9187
9188 return s32Ret;
9189 }
9190
HAL_AUDIO_PCM_HwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)9191 MS_U32 HAL_AUDIO_PCM_HwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
9192 {
9193 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9194 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9195 MS_S8 *pBufTmp = NULL;
9196 MS_U32 u32BufferSize = 0;
9197 MS_U32 u32PcmLevel = 0;
9198 MS_U32 u32RequestSize = 0;
9199 MS_U32 u32RequestSampleCount = 0;
9200 MS_U32 u32Loop = 0;
9201 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
9202
9203 if (pBuf == NULL)
9204 {
9205 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
9206 return 0;
9207 }
9208
9209 if (u32Size == 0)
9210 {
9211 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
9212 return 0;
9213 }
9214
9215 if (pPcmInfo->u8ConnectFlag == FALSE)
9216 {
9217 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9218 return 0;
9219 }
9220
9221 if (pPcmInfo->u8StartFlag == FALSE)
9222 {
9223 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
9224 return 0;
9225 }
9226
9227 pBufTmp = (MS_S8 *)pBuf;
9228
9229 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
9230 u32PcmLevel = u32PcmLevel * 2;
9231 if ((u32PcmLevel / BYTES_IN_MIU_LINE) <= 6)
9232 {
9233 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
9234
9235 u32PcmLevel = 0;
9236 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9237 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9238 HAL_AUDIO_PCM_HwDma_Reader1_Start();
9239 }
9240
9241 u32RequestSize = u32Size * 2;
9242 u32RequestSampleCount = u32Size / 2;
9243
9244 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
9245 u32BufferSize = u32BufferSize * 2;
9246
9247 /* copy data to PCM buffer */
9248 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
9249 {
9250 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
9251 {
9252 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9253 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L low, R low, L low, R low, ... */
9254 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L high, R high, L high, R high, ... */
9255 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
9256
9257 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9258 {
9259 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
9260 {
9261 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
9262 }
9263 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9264 }
9265 }
9266
9267 /* flush MIU */
9268 MsOS_FlushMemory();
9269
9270 /* update copied size to engine */
9271 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
9272 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, (u32RequestSize/BYTES_IN_MIU_LINE));
9273 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
9274 #ifdef MSOS_TYPE_LINUX_KERNEL
9275 udelay(50);
9276 #else
9277 AUDIO_DELAY1US(50);
9278 #endif
9279
9280 return u32Size;
9281 }
9282
9283 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
9284
9285 return 0;
9286 }
9287
HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)9288 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Flush(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 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
9294
9295 if (pPcmInfo->u8StartFlag == FALSE)
9296 {
9297 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9298 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
9299 }
9300
9301 return s32Ret;
9302 }
9303 #endif
9304
9305 #if AUDIO_HW_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)9306 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)
9307 {
9308 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9309 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9310 MS_U16 u16Divisor = 0;
9311 MS_U16 u16Synthrate = 0;
9312 MS_U32 u32TargetBufferSize = 0;
9313 MS_U32 u32TargetChannel = 0;
9314 MS_U32 u32TargetBitWidth = 0;
9315 MS_U32 u32TargetAlignmentSize = 0;
9316 MS_S32 s32Ret = 0;
9317
9318 /*
9319 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
9320 */
9321 switch(pPcmInfo->u32SampleRate) {
9322 case 8000:
9323 {
9324 u16Divisor = 2;
9325 u16Synthrate = 0x6978;
9326 break;
9327 }
9328
9329 case 11025:
9330 {
9331 u16Divisor = 2;
9332 u16Synthrate = 0x4C87;
9333 break;
9334 }
9335
9336 case 12000:
9337 {
9338 u16Divisor = 2;
9339 u16Synthrate = 0x4650;
9340 break;
9341 }
9342
9343 case 16000:
9344 {
9345 u16Divisor = 1;
9346 u16Synthrate = 0x6978;
9347 break;
9348 }
9349
9350 case 22050:
9351 {
9352 u16Divisor = 1;
9353 u16Synthrate = 0x4C87;
9354 break;
9355 }
9356
9357 case 24000:
9358 {
9359 u16Divisor = 1;
9360 u16Synthrate = 0x4650;
9361 break;
9362 }
9363
9364 case 32000:
9365 {
9366 u16Divisor = 0;
9367 u16Synthrate = 0x6978;
9368 break;
9369 }
9370
9371 case 44100:
9372 {
9373 u16Divisor = 0;
9374 u16Synthrate = 0x4C87;
9375 break;
9376 }
9377
9378 case 48000:
9379 {
9380 u16Divisor = 0;
9381 u16Synthrate = 0x4650;
9382 break;
9383 }
9384
9385 default:
9386 {
9387 u16Divisor = 0;
9388 u16Synthrate = 0x4650;
9389 pPcmInfo->u32SampleRate = 48000;
9390 break;
9391 }
9392 }
9393
9394 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9395 HAL_AUDIO_AbsWriteReg(NewDMAreader_ctrl, 0x0000);
9396 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0030, (u16Divisor << 4));
9397 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Syth, 0xFFFF, u16Synthrate);
9398
9399 /* enable DMA synthesizer */
9400 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0145, 0x0145);
9401
9402 /* calculate buffer size */
9403 u32TargetChannel = 2;
9404 u32TargetBitWidth = 16;
9405 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9406 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9407 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9408 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9409 {
9410 HALAUDIO_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);
9411 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9412 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
9413 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
9414 }
9415
9416 /* set buffer size */
9417 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9418
9419 /* set overrun & underrun threshold */
9420 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x0012);
9421
9422 pPCM->u8SettingChangeFlag = FALSE;
9423
9424 return s32Ret;
9425 }
9426
HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)9427 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)
9428 {
9429 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9430 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9431 MS_S32 s32Ret = 0;
9432
9433 if (pPcmInfo->u8ConnectFlag == FALSE)
9434 {
9435 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9436 return -A_EPERM;
9437 }
9438
9439 /* clear PCM buffer */
9440 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR2_BUF_SIZE);
9441
9442 /* flush MIU */
9443 MsOS_FlushMemory();
9444
9445 /* clear engine's write pointer */
9446 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, 0x0000);
9447
9448 /* reset & start engine */
9449 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
9450 #ifdef MSOS_TYPE_LINUX_KERNEL
9451 udelay(50);
9452 #else
9453 AUDIO_DELAY1US(50);
9454 #endif
9455 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
9456
9457 /* reset write pointer */
9458 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9459
9460 /* reset remain size */
9461 pPCM->tPcmBufferInfo.u32RemainSize = 0;
9462
9463 return s32Ret;
9464 }
9465
HAL_AUDIO_PCM_HwDma_Reader2_Open(void * pData)9466 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Open(void *pData)
9467 {
9468 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9469 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9470 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
9471 MS_U32 u32TargetBufferAddrPa = 0;
9472 MS_U32 u32TargetBufferSize = 0;
9473 MS_U32 u32TargetChannel = 0;
9474 MS_U32 u32TargetBitWidth = 0;
9475 MS_U32 u32TargetAlignmentSize = 0;
9476 MS_S32 s32Ret = 0;
9477 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
9478
9479 if (pData == NULL)
9480 {
9481 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9482 return -A_EFAULT;
9483 }
9484
9485 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9486
9487 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9488 {
9489 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9490 return -A_EINVAL;
9491 }
9492
9493 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9494 {
9495 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
9496 return -A_EINVAL;
9497 }
9498
9499 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9500 {
9501 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9502 return -A_EINVAL;
9503 }
9504
9505 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9506 {
9507 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
9508 return -A_EINVAL;
9509 }
9510
9511 if (pUserPcmInfo->u8CaptureFlag == TRUE)
9512 {
9513 HALAUDIO_ERROR("%s: Error! Not support capture mode!\n", __FUNCTION__);
9514 return -A_EINVAL;
9515 }
9516
9517 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)
9518 {
9519 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
9520 return -A_EINVAL;
9521 }
9522
9523 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)
9524 {
9525 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
9526 return -A_EINVAL;
9527 }
9528
9529 /* calculate buffer size */
9530 u32TargetChannel = 2;
9531 u32TargetBitWidth = 16;
9532 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9533 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9534 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9535 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9536 {
9537 HALAUDIO_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);
9538 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9539 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
9540 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
9541 }
9542
9543 /* fill in settings */
9544 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9545 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
9546 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
9547 pPcmInfo->u8ConnectFlag = TRUE;
9548 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9549 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
9550
9551 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
9552 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
9553 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
9554 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
9555 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
9556 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
9557 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
9558 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
9559 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
9560 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
9561
9562 /* init PCM buffer address */
9563 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR2_BUF_ADDR;
9564 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
9565 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
9566 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9567
9568 /* set PCM buffer address */
9569 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Lo, 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* RD_BASE_ADDR[15:0] */
9570 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Hi, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16) & 0xFFFF)); /* RD_BASE_ADDR[31:15] */
9571
9572 /* apply setting */
9573 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
9574
9575 /* restart */
9576 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
9577
9578 /* TODO : force channel6 to HW DMA Reader2, it's a hardcode */
9579 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x90);
9580
9581 return s32Ret;
9582 }
9583
HAL_AUDIO_PCM_HwDma_Reader2_Close(void)9584 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Close(void)
9585 {
9586 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9587 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9588 MS_S32 s32Ret = 0;
9589 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
9590
9591 if (pPcmInfo->u8ConnectFlag != FALSE)
9592 {
9593 HAL_AUDIO_PCM_HwDma_Reader2_Flush();
9594 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9595 }
9596
9597 return s32Ret;
9598 }
9599
HAL_AUDIO_PCM_HwDma_Reader2_Start(void)9600 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Start(void)
9601 {
9602 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9603 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9604 MS_S32 s32Ret = 0;
9605 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
9606
9607 if (pPcmInfo->u8StartFlag == FALSE)
9608 {
9609 if (pPCM->u8SettingChangeFlag == TRUE)
9610 {
9611 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
9612 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
9613 }
9614
9615 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0001);
9616 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0002);
9617
9618 pPcmInfo->u8StartFlag = TRUE;
9619 }
9620
9621 return s32Ret;
9622 }
9623
HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)9624 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)
9625 {
9626 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9627 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9628 MS_S32 s32Ret = 0;
9629 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
9630
9631 if (pPcmInfo->u8StartFlag != FALSE)
9632 {
9633 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0000);
9634 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0000);
9635
9636 pPcmInfo->u8StartFlag = FALSE;
9637 }
9638
9639 return s32Ret;
9640 }
9641
HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd,const void * pData)9642 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
9643 {
9644 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9645 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9646 MS_S32 s32Ret = 0;
9647 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9648
9649 if (pData == NULL)
9650 {
9651 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9652 return -A_EFAULT;
9653 }
9654
9655 if (pPcmInfo->u8ConnectFlag == FALSE)
9656 {
9657 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9658 return -A_EPERM;
9659 }
9660
9661 switch(u32Cmd)
9662 {
9663 case AUDIO_PCM_CMD_NONBLOCKING:
9664 {
9665 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
9666
9667 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
9668 {
9669 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
9670 s32Ret = -A_EINVAL;
9671 break;
9672 }
9673
9674 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
9675
9676 break;
9677 }
9678
9679 case AUDIO_PCM_CMD_MULTICH:
9680 {
9681 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
9682
9683 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
9684 {
9685 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
9686 s32Ret = -A_EINVAL;
9687 break;
9688 }
9689
9690 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9691 {
9692 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9693 s32Ret = -A_EINVAL;
9694 break;
9695 }
9696
9697 pPcmInfo->u8MultiChFlag = FALSE;
9698
9699 break;
9700 }
9701
9702 case AUDIO_PCM_CMD_MIXING:
9703 {
9704 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
9705
9706 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
9707 {
9708 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
9709 s32Ret = -A_EINVAL;
9710 break;
9711 }
9712
9713 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9714 {
9715 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
9716 s32Ret = -A_EINVAL;
9717 break;
9718 }
9719
9720 pPcmInfo->u8MixingFlag = FALSE;
9721
9722 break;
9723 }
9724
9725 case AUDIO_PCM_CMD_MIXINGGROUP:
9726 {
9727 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
9728
9729 pPcmInfo->u32MixingGroup = u32MixingGroup;
9730
9731 break;
9732 }
9733
9734 case AUDIO_PCM_CMD_BUFFERDURATION:
9735 {
9736 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
9737
9738 if (u32BufferDuration == 0)
9739 {
9740 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
9741 s32Ret = -A_EINVAL;
9742 break;
9743 }
9744
9745 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
9746 {
9747 pPcmInfo->u32BufferDuration = u32BufferDuration;
9748 pPCM->u8SettingChangeFlag = TRUE;
9749 }
9750
9751 break;
9752 }
9753
9754 case AUDIO_PCM_CMD_CHANNEL:
9755 {
9756 MS_U32 u32Channel = *((MS_U32 *)pData);
9757
9758 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9759 {
9760 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
9761 return -A_EINVAL;
9762 }
9763
9764 pPcmInfo->u32Channel = u32Channel;
9765
9766 break;
9767 }
9768
9769 case AUDIO_PCM_CMD_SAMPLERATE:
9770 {
9771 MS_U32 u32SampleRate = *((MS_U32 *)pData);
9772
9773 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9774 {
9775 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
9776 return -A_EINVAL;
9777 }
9778
9779 if (pPcmInfo->u32SampleRate != u32SampleRate)
9780 {
9781 pPcmInfo->u32SampleRate = u32SampleRate;
9782 pPCM->u8SettingChangeFlag = TRUE;
9783 }
9784
9785 break;
9786 }
9787
9788 case AUDIO_PCM_CMD_BITWIDTH:
9789 {
9790 MS_U32 u32BitWidth = *((MS_U32 *)pData);
9791
9792 pPcmInfo->u32BitWidth = u32BitWidth;
9793
9794 break;
9795 }
9796
9797 case AUDIO_PCM_CMD_BIGENDIAN:
9798 {
9799 MS_U32 u32BigEndian = *((MS_U32 *)pData);
9800
9801 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
9802 {
9803 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
9804 return -A_EINVAL;
9805 }
9806
9807 pPcmInfo->u32BigEndian = u32BigEndian;
9808
9809 break;
9810 }
9811
9812 case AUDIO_PCM_CMD_TIMESTAMP:
9813 {
9814 MS_U32 u32Timestamp = *((MS_U32 *)pData);
9815
9816 pPcmInfo->u32Timestamp = u32Timestamp;
9817
9818 break;
9819 }
9820
9821 case AUDIO_PCM_CMD_WEIGHTING:
9822 {
9823 MS_U32 u32Weighting = *((MS_U32 *)pData);
9824
9825 if (u32Weighting > 100)
9826 {
9827 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
9828 return -A_EINVAL;
9829 }
9830
9831 pPcmInfo->u32Weighting = u32Weighting;
9832
9833 break;
9834 }
9835
9836 case AUDIO_PCM_CMD_VOLUME:
9837 {
9838 MS_U32 u32Volume = *((MS_U32 *)pData);
9839
9840 if (u32Volume > 100)
9841 {
9842 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
9843 return -A_EINVAL;
9844 }
9845
9846 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
9847
9848 break;
9849 }
9850
9851 case AUDIO_PCM_CMD_MUTE:
9852 {
9853 MS_U32 u32Mute = *((MS_U32*)pData);
9854
9855 if (u32Mute == TRUE)
9856 {
9857 pPcmInfo->u32Volume |= 0x80000000;
9858 }
9859 else if (u32Mute == FALSE)
9860 {
9861 pPcmInfo->u32Volume &= 0x7FFFFFFF;
9862 }
9863 else
9864 {
9865 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
9866 s32Ret = -A_EINVAL;
9867 }
9868 break;
9869 }
9870
9871 default:
9872 {
9873 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
9874 break;
9875 }
9876 }
9877
9878 return s32Ret;
9879 }
9880
HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd,void * pData)9881 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd, void *pData)
9882 {
9883 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9884 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9885 MS_S32 s32Ret = 0;
9886 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9887
9888 if (pData == NULL)
9889 {
9890 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9891 return -A_EFAULT;
9892 }
9893
9894 if (pPcmInfo->u8ConnectFlag == FALSE)
9895 {
9896 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9897 return -A_EPERM;
9898 }
9899
9900 switch(u32Cmd)
9901 {
9902 case AUDIO_PCM_CMD_ALL:
9903 {
9904 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9905 MS_U32 u32MinSize = 0;
9906
9907 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9908 {
9909 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9910 s32Ret = -A_EINVAL;
9911 break;
9912 }
9913 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
9914 {
9915 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9916 }
9917
9918 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
9919 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
9920 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
9921
9922 break;
9923 }
9924
9925 case AUDIO_PCM_CMD_NONBLOCKING:
9926 {
9927 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9928 break;
9929 }
9930
9931 case AUDIO_PCM_CMD_MULTICH:
9932 {
9933 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9934 break;
9935 }
9936
9937 case AUDIO_PCM_CMD_MIXING:
9938 {
9939 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9940 break;
9941 }
9942
9943 case AUDIO_PCM_CMD_MIXINGGROUP:
9944 {
9945 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9946 break;
9947 }
9948
9949 case AUDIO_PCM_CMD_BUFFER:
9950 {
9951 /*
9952 * TODO, need better coding
9953 *
9954 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
9955 */
9956 break;
9957 }
9958
9959 case AUDIO_PCM_CMD_BUFFERDURATION:
9960 {
9961 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9962 break;
9963 }
9964
9965 case AUDIO_PCM_CMD_READPTR:
9966 {
9967 /*
9968 * TODO, need better coding
9969 *
9970 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
9971 */
9972 break;
9973 }
9974
9975 case AUDIO_PCM_CMD_WRITEPTR:
9976 {
9977 /*
9978 * TODO, need better coding
9979 *
9980 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
9981 */
9982 break;
9983 }
9984
9985 case AUDIO_PCM_CMD_CHANNEL:
9986 {
9987 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9988 break;
9989 }
9990
9991 case AUDIO_PCM_CMD_SAMPLERATE:
9992 {
9993 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9994 break;
9995 }
9996
9997 case AUDIO_PCM_CMD_BITWIDTH:
9998 {
9999 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10000 break;
10001 }
10002
10003 case AUDIO_PCM_CMD_BIGENDIAN:
10004 {
10005 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10006 break;
10007 }
10008
10009 case AUDIO_PCM_CMD_TIMESTAMP:
10010 {
10011 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10012 break;
10013 }
10014
10015 case AUDIO_PCM_CMD_WEIGHTING:
10016 {
10017 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10018 break;
10019 }
10020
10021 case AUDIO_PCM_CMD_VOLUME:
10022 {
10023 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10024 break;
10025 }
10026
10027 case AUDIO_PCM_CMD_BUFFERLEVEL:
10028 {
10029 MS_U32 u32BufferLevel1 = 0;
10030 MS_U32 u32BufferLevel2 = 0;
10031 MS_U32 u32Timeout = 20;
10032
10033 while (u32Timeout > 0)
10034 {
10035 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0020);
10036 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10037 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
10038 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0000);
10039
10040 if (u32BufferLevel1 == u32BufferLevel2)
10041 {
10042 break;
10043 }
10044
10045 u32Timeout--;
10046
10047 #ifdef MSOS_TYPE_LINUX_KERNEL
10048 udelay(1);
10049 #else
10050 AUDIO_DELAY1US(1);
10051 #endif
10052 }
10053
10054 if (u32BufferLevel1 != u32BufferLevel2)
10055 {
10056 HALAUDIO_ERROR("%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
10057 }
10058
10059 pPcmInfo->u32BufferLevel = u32BufferLevel2;
10060 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10061
10062 break;
10063 }
10064
10065 case AUDIO_PCM_CMD_MUTE:
10066 {
10067 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10068 break;
10069 }
10070
10071 case AUDIO_PCM_CMD_BUFFERSIZE:
10072 {
10073 *((MS_U32 *)pData) = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_size) * BYTES_IN_MIU_LINE;
10074 break;
10075 }
10076
10077 default:
10078 {
10079 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10080 break;
10081 }
10082 }
10083
10084 return s32Ret;
10085 }
10086
HAL_AUDIO_PCM_HwDma_Reader2_Write(const void * pBuf,MS_U32 u32Size)10087 MS_U32 HAL_AUDIO_PCM_HwDma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
10088 {
10089 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10090 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10091 MS_S8 *pBufTmp = NULL;
10092 MS_U32 u32BufferSize = 0;
10093 MS_U32 u32PcmLevel = 0;
10094 MS_U32 u32RequestSize = 0;
10095 MS_U32 u32RequestSizeTmp = 0;
10096 MS_U32 u32SizeToCopy = 0;
10097 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10098
10099 if (pBuf == NULL)
10100 {
10101 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10102 return 0;
10103 }
10104
10105 if (u32Size == 0)
10106 {
10107 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
10108 return 0;
10109 }
10110
10111 if (pPcmInfo->u8ConnectFlag == FALSE)
10112 {
10113 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10114 return 0;
10115 }
10116
10117 if (pPcmInfo->u8StartFlag == FALSE)
10118 {
10119 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
10120 return 0;
10121 }
10122
10123 pBufTmp = (MS_S8 *)pBuf;
10124
10125 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10126 if (u32PcmLevel == 0)
10127 {
10128 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10129 }
10130
10131 u32RequestSize = u32Size;
10132 u32RequestSizeTmp = u32RequestSize;
10133
10134 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
10135
10136 /* copy data to PCM buffer */
10137 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
10138 {
10139 do {
10140 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
10141 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
10142
10143 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10144
10145 pBufTmp += u32SizeToCopy;
10146 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
10147 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10148 {
10149 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10150 {
10151 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
10152 }
10153 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10154 }
10155
10156 u32RequestSizeTmp -= u32SizeToCopy;
10157 } while (u32RequestSizeTmp > 0);
10158
10159 /* flush MIU */
10160 MsOS_FlushMemory();
10161
10162 /* update copied size to engine */
10163 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
10164 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0000);
10165 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
10166 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0010);
10167 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
10168
10169 return u32Size;
10170 }
10171
10172 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
10173
10174 return 0;
10175 }
10176
HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)10177 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)
10178 {
10179 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10180 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10181 MS_S32 s32Ret = 0;
10182 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
10183
10184 if (pPcmInfo->u8StartFlag == FALSE)
10185 {
10186 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10187 HAL_AUDIO_PCM_HwDma_Reader2_Stop();
10188 }
10189
10190 return s32Ret;
10191 }
10192 #endif
10193
10194 #if AUDIO_SW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)10195 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)
10196 {
10197 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10198 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10199 MS_U16 u16Synthrate_H = 0;
10200 MS_U16 u16Synthrate_L = 0;
10201 MS_U32 u32TargetBufferSize = 0;
10202 MS_U32 u32TargetChannel = 0;
10203 MS_U32 u32TargetBitWidth = 0;
10204 MS_U32 u32TargetAlignmentSize = 0;
10205 MS_S32 s32Ret = 0;
10206
10207 switch(pPcmInfo->u32SampleRate) {
10208 case 8000:
10209 {
10210 u16Synthrate_H = 0x6978;
10211 u16Synthrate_L = 0x0000;
10212 break;
10213 }
10214
10215 case 11025:
10216 {
10217 u16Synthrate_H = 0x4C87;
10218 u16Synthrate_L = 0xD634;
10219 break;
10220 }
10221
10222 case 12000:
10223 {
10224 u16Synthrate_H = 0x4650;
10225 u16Synthrate_L = 0x0000;
10226 break;
10227 }
10228
10229 case 16000:
10230 {
10231 u16Synthrate_H = 0x34BC;
10232 u16Synthrate_L = 0x0000;
10233 break;
10234 }
10235
10236 case 22050:
10237 {
10238 u16Synthrate_H = 0x2643;
10239 u16Synthrate_L = 0xEB1A;
10240 break;
10241 }
10242
10243 case 24000:
10244 {
10245 u16Synthrate_H = 0x2328;
10246 u16Synthrate_L = 0x0000;
10247 break;
10248 }
10249
10250 case 32000:
10251 {
10252 u16Synthrate_H = 0x1A5E;
10253 u16Synthrate_L = 0x0000;
10254 break;
10255 }
10256
10257 case 44100:
10258 {
10259 u16Synthrate_H = 0x1321;
10260 u16Synthrate_L = 0xF58D;
10261 break;
10262 }
10263
10264 case 48000:
10265 {
10266 u16Synthrate_H = 0x1194;
10267 u16Synthrate_L = 0x0000;
10268 break;
10269 }
10270
10271 case 96000:
10272 {
10273 u16Synthrate_H = 0x08CA;
10274 u16Synthrate_L = 0x0000;
10275 break;
10276 }
10277
10278 default:
10279 {
10280 u16Synthrate_H = 0x1194;
10281 u16Synthrate_L = 0x0000;
10282 pPcmInfo->u32SampleRate = 48000;
10283 break;
10284 }
10285 }
10286
10287 /* configure sample rate */
10288 #ifdef M2S_MBOX_SW_DMA_READER_DDR_SynthFreq_H //TODO : need to remove this, DSP side first then Driver side.
10289 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_SynthFreq_H, 0xFFFF, u16Synthrate_H);
10290 #endif
10291 HAL_MAD2_Write_DSP_sram(DSP2DmAddr_swDmaRdr_synthFreq_H, u16Synthrate_H, DSP_MEM_TYPE_DM);
10292 HAL_MAD2_Write_DSP_sram(DSP2DmAddr_swDmaRdr_synthFreq_L, u16Synthrate_L, DSP_MEM_TYPE_DM);
10293
10294 /* calculate buffer size */
10295 u32TargetChannel = 2;
10296 u32TargetBitWidth = 16;
10297 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10298 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10299 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10300 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10301 {
10302 HALAUDIO_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);
10303 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10304 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10305 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
10306 }
10307
10308 pPCM->u8SettingChangeFlag = FALSE;
10309
10310 return s32Ret;
10311 }
10312
HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)10313 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)
10314 {
10315 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10316 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10317 MS_S32 s32Ret = 0;
10318
10319 if (pPcmInfo->u8ConnectFlag == FALSE)
10320 {
10321 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10322 return -A_EPERM;
10323 }
10324
10325 /* clear PCM buffer */
10326 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, SW_DMA_RDR1_BUF_SIZE);
10327
10328 /* flush MIU */
10329 MsOS_FlushMemory();
10330
10331 /* clear engine's write pointer */
10332 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, 0x0000);
10333
10334 /* reset engine, no start engine here! */
10335 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0001);
10336
10337 /* reset write pointer */
10338 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10339
10340 /* reset remain size */
10341 pPCM->tPcmBufferInfo.u32RemainSize = 0;
10342
10343 return s32Ret;
10344 }
10345
HAL_AUDIO_PCM_SwDma_Reader1_Open(void * pData)10346 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Open(void *pData)
10347 {
10348 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10349 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10350 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10351 MS_U32 u32TargetBufferAddrPa = 0;
10352 MS_U32 u32TargetBufferSize = 0;
10353 MS_U32 u32TargetChannel = 0;
10354 MS_U32 u32TargetBitWidth = 0;
10355 MS_U32 u32TargetAlignmentSize = 0;
10356 MS_S32 s32Ret = 0;
10357 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10358
10359 if (pData == NULL)
10360 {
10361 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10362 return -A_EFAULT;
10363 }
10364
10365 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10366
10367 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10368 {
10369 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10370 return -A_EINVAL;
10371 }
10372
10373 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10374 {
10375 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
10376 return -A_EINVAL;
10377 }
10378
10379 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10380 {
10381 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10382 return -A_EINVAL;
10383 }
10384
10385 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10386 {
10387 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10388 return -A_EINVAL;
10389 }
10390
10391 if (pUserPcmInfo->u8CaptureFlag == TRUE)
10392 {
10393 HALAUDIO_ERROR("%s: Error! Not support capture mode!\n", __FUNCTION__);
10394 return -A_EINVAL;
10395 }
10396
10397 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)
10398 {
10399 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
10400 return -A_EINVAL;
10401 }
10402
10403 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)
10404 {
10405 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
10406 return -A_EINVAL;
10407 }
10408
10409 /* calculate buffer size */
10410 u32TargetChannel = 2;
10411 u32TargetBitWidth = 16;
10412 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10413 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10414 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10415 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10416 {
10417 HALAUDIO_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);
10418 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10419 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10420 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
10421 }
10422
10423 /* fill in settings */
10424 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10425 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10426 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10427 pPcmInfo->u8ConnectFlag = TRUE;
10428 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10429 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
10430 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10431 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10432 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10433 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10434 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10435 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10436 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10437 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
10438 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10439 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10440
10441 /* init PCM buffer address */
10442 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + SW_DMA_RDR1_BUF_ADDR;
10443 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10444 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
10445 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10446
10447 /* apply setting */
10448 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
10449
10450 /* restart */
10451 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
10452
10453 /* TODO : force channel6 to SW DMA Reader, it's a hardcode */
10454 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x0F,0x00);
10455 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x82);
10456
10457 return s32Ret;
10458 }
10459
HAL_AUDIO_PCM_SwDma_Reader1_Close(void)10460 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Close(void)
10461 {
10462 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10463 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10464 MS_S32 s32Ret = 0;
10465 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10466
10467 if (pPcmInfo->u8ConnectFlag != FALSE)
10468 {
10469 HAL_AUDIO_PCM_SwDma_Reader1_Flush();
10470 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10471 }
10472
10473 return s32Ret;
10474 }
10475
HAL_AUDIO_PCM_SwDma_Reader1_Start(void)10476 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Start(void)
10477 {
10478 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10479 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10480 MS_S32 s32Ret = 0;
10481 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10482
10483 if (pPcmInfo->u8StartFlag == FALSE)
10484 {
10485 if (pPCM->u8SettingChangeFlag == TRUE)
10486 {
10487 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
10488 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
10489 }
10490
10491 /* start engine */
10492 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0002);
10493
10494 pPcmInfo->u8StartFlag = TRUE;
10495 }
10496
10497 return s32Ret;
10498 }
10499
HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)10500 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)
10501 {
10502 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10503 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10504 MS_S32 s32Ret = 0;
10505 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10506
10507 if (pPcmInfo->u8StartFlag != FALSE)
10508 {
10509 /* stop engine */
10510 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0000);
10511
10512 pPcmInfo->u8StartFlag = FALSE;
10513 }
10514
10515 return s32Ret;
10516 }
10517
HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)10518 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
10519 {
10520 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10521 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10522 MS_S32 s32Ret = 0;
10523 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10524
10525 if (pData == NULL)
10526 {
10527 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10528 return -A_EFAULT;
10529 }
10530
10531 if (pPcmInfo->u8ConnectFlag == FALSE)
10532 {
10533 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10534 return -A_EPERM;
10535 }
10536
10537 switch(u32Cmd)
10538 {
10539 case AUDIO_PCM_CMD_NONBLOCKING:
10540 {
10541 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10542
10543 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10544 {
10545 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10546 s32Ret = -A_EINVAL;
10547 break;
10548 }
10549
10550 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10551
10552 break;
10553 }
10554
10555 case AUDIO_PCM_CMD_MULTICH:
10556 {
10557 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10558
10559 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10560 {
10561 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10562 s32Ret = -A_EINVAL;
10563 break;
10564 }
10565
10566 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10567 {
10568 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10569 s32Ret = -A_EINVAL;
10570 break;
10571 }
10572
10573 pPcmInfo->u8MultiChFlag = FALSE;
10574
10575 break;
10576 }
10577
10578 case AUDIO_PCM_CMD_MIXING:
10579 {
10580 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10581
10582 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10583 {
10584 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10585 s32Ret = -A_EINVAL;
10586 break;
10587 }
10588
10589 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10590 {
10591 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10592 s32Ret = -A_EINVAL;
10593 break;
10594 }
10595
10596 pPcmInfo->u8MixingFlag = FALSE;
10597
10598 break;
10599 }
10600
10601 case AUDIO_PCM_CMD_MIXINGGROUP:
10602 {
10603 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10604
10605 pPcmInfo->u32MixingGroup = u32MixingGroup;
10606
10607 break;
10608 }
10609
10610 case AUDIO_PCM_CMD_BUFFERDURATION:
10611 {
10612 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
10613
10614 if (u32BufferDuration == 0)
10615 {
10616 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
10617 s32Ret = -A_EINVAL;
10618 break;
10619 }
10620
10621 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
10622 {
10623 pPcmInfo->u32BufferDuration = u32BufferDuration;
10624 pPCM->u8SettingChangeFlag = TRUE;
10625 }
10626
10627 break;
10628 }
10629
10630 case AUDIO_PCM_CMD_CHANNEL:
10631 {
10632 MS_U32 u32Channel = *((MS_U32 *)pData);
10633
10634 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10635 {
10636 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
10637 return -A_EINVAL;
10638 }
10639
10640 if (pPcmInfo->u32Channel != u32Channel)
10641 {
10642 pPcmInfo->u32Channel = u32Channel;
10643 pPCM->u8SettingChangeFlag = TRUE;
10644 }
10645
10646 break;
10647 }
10648
10649 case AUDIO_PCM_CMD_SAMPLERATE:
10650 {
10651 MS_U32 u32SampleRate = *((MS_U32 *)pData);
10652
10653 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10654 {
10655 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
10656 return -A_EINVAL;
10657 }
10658
10659 if (pPcmInfo->u32SampleRate != u32SampleRate)
10660 {
10661 pPcmInfo->u32SampleRate = u32SampleRate;
10662 pPCM->u8SettingChangeFlag = TRUE;
10663 }
10664
10665 break;
10666 }
10667
10668 case AUDIO_PCM_CMD_BITWIDTH:
10669 {
10670 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10671
10672 pPcmInfo->u32BitWidth = u32BitWidth;
10673
10674 break;
10675 }
10676
10677 case AUDIO_PCM_CMD_BIGENDIAN:
10678 {
10679 MS_U32 u32BigEndian = *((MS_U32 *)pData);
10680
10681 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
10682 {
10683 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
10684 return -A_EINVAL;
10685 }
10686
10687 pPcmInfo->u32BigEndian = u32BigEndian;
10688
10689 break;
10690 }
10691
10692 case AUDIO_PCM_CMD_TIMESTAMP:
10693 {
10694 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10695
10696 pPcmInfo->u32Timestamp = u32Timestamp;
10697
10698 break;
10699 }
10700
10701 case AUDIO_PCM_CMD_WEIGHTING:
10702 {
10703 MS_U32 u32Weighting = *((MS_U32 *)pData);
10704
10705 if (u32Weighting > 100)
10706 {
10707 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
10708 return -A_EINVAL;
10709 }
10710
10711 pPcmInfo->u32Weighting = u32Weighting;
10712
10713 break;
10714 }
10715
10716 case AUDIO_PCM_CMD_VOLUME:
10717 {
10718 MS_U32 u32Volume = *((MS_U32 *)pData);
10719
10720 if (u32Volume > 100)
10721 {
10722 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
10723 return -A_EINVAL;
10724 }
10725
10726 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
10727
10728 break;
10729 }
10730
10731 case AUDIO_PCM_CMD_MUTE:
10732 {
10733 MS_U32 u32Mute = *((MS_U32*)pData);
10734
10735 if (u32Mute == TRUE)
10736 {
10737 pPcmInfo->u32Volume |= 0x80000000;
10738 }
10739 else if (u32Mute == FALSE)
10740 {
10741 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10742 }
10743 else
10744 {
10745 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
10746 s32Ret = -A_EINVAL;
10747 }
10748 break;
10749 }
10750
10751 default:
10752 {
10753 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10754 break;
10755 }
10756 }
10757
10758 return s32Ret;
10759 }
10760
HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)10761 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
10762 {
10763 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10764 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10765 MS_S32 s32Ret = 0;
10766 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10767
10768 if (pData == NULL)
10769 {
10770 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10771 return -A_EFAULT;
10772 }
10773
10774 if (pPcmInfo->u8ConnectFlag == FALSE)
10775 {
10776 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10777 return -A_EPERM;
10778 }
10779
10780 switch(u32Cmd)
10781 {
10782 case AUDIO_PCM_CMD_ALL:
10783 {
10784 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10785 MS_U32 u32MinSize = 0;
10786
10787 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10788 {
10789 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10790 s32Ret = -A_EINVAL;
10791 break;
10792 }
10793 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
10794 {
10795 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10796 }
10797
10798 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
10799 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
10800 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
10801
10802 break;
10803 }
10804
10805 case AUDIO_PCM_CMD_NONBLOCKING:
10806 {
10807 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
10808 break;
10809 }
10810
10811 case AUDIO_PCM_CMD_MULTICH:
10812 {
10813 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
10814 break;
10815 }
10816
10817 case AUDIO_PCM_CMD_MIXING:
10818 {
10819 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
10820 break;
10821 }
10822
10823 case AUDIO_PCM_CMD_MIXINGGROUP:
10824 {
10825 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
10826 break;
10827 }
10828
10829 case AUDIO_PCM_CMD_BUFFER:
10830 {
10831 /*
10832 * TODO, need better coding
10833 *
10834 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
10835 */
10836 break;
10837 }
10838
10839 case AUDIO_PCM_CMD_BUFFERDURATION:
10840 {
10841 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
10842 break;
10843 }
10844
10845 case AUDIO_PCM_CMD_READPTR:
10846 {
10847 /*
10848 * TODO, need better coding
10849 *
10850 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
10851 */
10852 break;
10853 }
10854
10855 case AUDIO_PCM_CMD_WRITEPTR:
10856 {
10857 /*
10858 * TODO, need better coding
10859 *
10860 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
10861 */
10862 break;
10863 }
10864
10865 case AUDIO_PCM_CMD_CHANNEL:
10866 {
10867 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
10868 break;
10869 }
10870
10871 case AUDIO_PCM_CMD_SAMPLERATE:
10872 {
10873 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
10874 break;
10875 }
10876
10877 case AUDIO_PCM_CMD_BITWIDTH:
10878 {
10879 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10880 break;
10881 }
10882
10883 case AUDIO_PCM_CMD_BIGENDIAN:
10884 {
10885 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10886 break;
10887 }
10888
10889 case AUDIO_PCM_CMD_TIMESTAMP:
10890 {
10891 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10892 break;
10893 }
10894
10895 case AUDIO_PCM_CMD_WEIGHTING:
10896 {
10897 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10898 break;
10899 }
10900
10901 case AUDIO_PCM_CMD_VOLUME:
10902 {
10903 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10904 break;
10905 }
10906
10907 case AUDIO_PCM_CMD_BUFFERLEVEL:
10908 {
10909 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0008);
10910 pPcmInfo->u32BufferLevel = HAL_AUDIO_ReadReg(S2M_MBOX_SW_DMA_READER_DDR_Level) * BYTES_IN_MIU_LINE;
10911 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0000);
10912 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10913 break;
10914 }
10915
10916 case AUDIO_PCM_CMD_MUTE:
10917 {
10918 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10919 break;
10920 }
10921
10922 case AUDIO_PCM_CMD_BUFFERSIZE:
10923 {
10924 MS_U32 u32TargetBufferSize = 0;
10925 MS_U32 u32TargetChannel = 0;
10926 MS_U32 u32TargetBitWidth = 0;
10927
10928 u32TargetChannel = 2;
10929 u32TargetBitWidth = 16;
10930 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10931
10932 *((MS_U32 *)pData) = u32TargetBufferSize;
10933
10934 break;
10935 }
10936
10937 default:
10938 {
10939 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10940 break;
10941 }
10942 }
10943
10944 return s32Ret;
10945 }
10946
HAL_AUDIO_PCM_SwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)10947 MS_U32 HAL_AUDIO_PCM_SwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
10948 {
10949 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10950 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10951 MS_S8 *pBufTmp = NULL;
10952 MS_U32 u32BufferSize = 0;
10953 MS_U32 u32PcmLevel = 0;
10954 MS_U32 u32RequestSize = 0;
10955 MS_U32 u32RequestSizeTmp = 0;
10956 MS_U32 u32SizeToCopy = 0;
10957 MS_U32 u32WptrOffset = 0;
10958 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10959
10960 if (pBuf == NULL)
10961 {
10962 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10963 return 0;
10964 }
10965
10966 if (u32Size == 0)
10967 {
10968 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
10969 return 0;
10970 }
10971
10972 if (pPcmInfo->u8ConnectFlag == FALSE)
10973 {
10974 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10975 return 0;
10976 }
10977
10978 if (pPcmInfo->u8StartFlag == FALSE)
10979 {
10980 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
10981 return 0;
10982 }
10983
10984 pBufTmp = (MS_S8 *)pBuf;
10985
10986 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10987 if (u32PcmLevel == 0)
10988 {
10989 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10990 }
10991
10992 u32RequestSize = u32Size;
10993 u32RequestSizeTmp = u32RequestSize;
10994
10995 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
10996
10997 /* copy data to PCM buffer */
10998 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
10999 {
11000 do {
11001 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE) - pPCM->tPcmBufferInfo.pWritePtr;
11002 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11003
11004 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11005
11006 pBufTmp += u32SizeToCopy;
11007 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
11008 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11009 {
11010 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
11011 {
11012 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11013 }
11014 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11015 }
11016
11017 u32RequestSizeTmp -= u32SizeToCopy;
11018 } while (u32RequestSizeTmp > 0);
11019
11020 /* flush MIU */
11021 MsOS_FlushMemory();
11022
11023 /* update write pointers to engine */
11024 u32WptrOffset = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pBuffer;
11025 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, (u32WptrOffset / BYTES_IN_MIU_LINE));
11026
11027 return u32Size;
11028 }
11029
11030 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
11031
11032 return 0;
11033 }
11034
HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)11035 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)
11036 {
11037 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11038 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11039 MS_S32 s32Ret = 0;
11040 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
11041
11042 if (pPcmInfo->u8StartFlag == FALSE)
11043 {
11044 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11045 HAL_AUDIO_PCM_SwDma_Reader1_Stop();
11046 }
11047
11048 return s32Ret;
11049 }
11050 #endif
11051
11052 #if AUDIO_R2_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)11053 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)
11054 {
11055 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11056 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11057 MS_U16 u16Val = 0;
11058 MS_U16 u16Synthrate_H = 0;
11059 MS_U16 u16Synthrate_L = 0;
11060 MS_U32 u32TargetBufferSize = 0;
11061 MS_U32 u32TargetChannel = 0;
11062 MS_U32 u32TargetBitWidth = 0;
11063 MS_U32 u32TargetAlignmentSize = 0;
11064 MS_S32 s32Ret = 0;
11065
11066 switch(pPcmInfo->u32SampleRate) {
11067 case 8000:
11068 {
11069 u16Synthrate_H = 0x6978;
11070 u16Synthrate_L = 0x0000;
11071 break;
11072 }
11073
11074 case 11025:
11075 {
11076 u16Synthrate_H = 0x4C87;
11077 u16Synthrate_L = 0xD634;
11078 break;
11079 }
11080
11081 case 12000:
11082 {
11083 u16Synthrate_H = 0x4650;
11084 u16Synthrate_L = 0x0000;
11085 break;
11086 }
11087
11088 case 16000:
11089 {
11090 u16Synthrate_H = 0x34BC;
11091 u16Synthrate_L = 0x0000;
11092 break;
11093 }
11094
11095 case 22050:
11096 {
11097 u16Synthrate_H = 0x2643;
11098 u16Synthrate_L = 0xEB1A;
11099 break;
11100 }
11101
11102 case 24000:
11103 {
11104 u16Synthrate_H = 0x2328;
11105 u16Synthrate_L = 0x0000;
11106 break;
11107 }
11108
11109 case 32000:
11110 {
11111 u16Synthrate_H = 0x1A5E;
11112 u16Synthrate_L = 0x0000;
11113 break;
11114 }
11115
11116 case 44100:
11117 {
11118 u16Synthrate_H = 0x1321;
11119 u16Synthrate_L = 0xF58D;
11120 break;
11121 }
11122
11123 case 48000:
11124 {
11125 u16Synthrate_H = 0x1194;
11126 u16Synthrate_L = 0x0000;
11127 break;
11128 }
11129
11130 case 96000:
11131 {
11132 u16Synthrate_H = 0x08CA;
11133 u16Synthrate_L = 0x0000;
11134 break;
11135 }
11136
11137 default:
11138 {
11139 u16Synthrate_H = 0x1194;
11140 u16Synthrate_L = 0x0000;
11141 pPcmInfo->u32SampleRate = 48000;
11142 break;
11143 }
11144 }
11145
11146 /* disable output */
11147 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x7FFF, 0x0000);
11148
11149 /* set synthesizer */
11150 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
11151 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
11152 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11153 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0101); /* SYTH1 bit8RIU control, bit0 update */
11154 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
11155
11156 if (pPcmInfo->u8MultiChFlag == TRUE)
11157 {
11158 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11159 u32TargetChannel = 10;
11160 }
11161 else
11162 {
11163 /* stereo = 2 channels */
11164 u32TargetChannel = 2;
11165 }
11166
11167 /* calculate buffer size */
11168 u32TargetBitWidth = 16;
11169 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11170 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11171 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11172 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11173 {
11174 HALAUDIO_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);
11175 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11176 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11177 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
11178 }
11179
11180 /* set buffer size */
11181 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
11182
11183 /* set overrun & underrun threshold */
11184 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize >> 3)) / BYTES_IN_MIU_LINE));
11185 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
11186
11187 /* set channel mode */
11188 if (pPcmInfo->u8MultiChFlag == TRUE)
11189 {
11190 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11191 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x00);
11192 u16Val = 19; /* MIU burst length = 19 */
11193 u16Val += (1 << 7); /* MIU Step En = 1 */
11194 u16Val += (1 << 15); /* Sync Valid En = 1 */
11195 u16Val += (1 << 8); /* Sync Step Count = 1 */
11196 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11197 }
11198 else
11199 {
11200 /* Stereo mode : stereo = 2 channels */
11201 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x80);
11202 u16Val = 3; /* MIU burst length = 3 */
11203 u16Val += (0 << 7); /* MIU Step En = 0 */
11204 u16Val += (0 << 15); /* Sync Valid En = 0 */
11205 u16Val += (1 << 8); /* Sync Step Count = 1 */
11206 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
11207 }
11208
11209 /* set 16 Bit mode */
11210 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0860, 0x0020);
11211
11212 pPCM->u8SettingChangeFlag = FALSE;
11213
11214 return s32Ret;
11215 }
11216
HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)11217 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)
11218 {
11219 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11220 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11221 MS_S32 s32Ret = 0;
11222
11223 if (pPcmInfo->u8ConnectFlag == FALSE)
11224 {
11225 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11226 return -A_EPERM;
11227 }
11228
11229 /* stop engine */
11230 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0000);
11231
11232 /* clear PCM buffer */
11233 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR1_BUF_SIZE);
11234
11235 /* flush MIU */
11236 MsOS_FlushMemory();
11237
11238 /* initial dlocal buffer */
11239 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x2000);
11240 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x0000);
11241
11242 /* reset engine */
11243 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x1000);
11244 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x0000);
11245
11246 /* start engine */
11247 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0002);
11248
11249 /* reset write pointer */
11250 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11251
11252 /* reset remain size */
11253 pPCM->tPcmBufferInfo.u32RemainSize = 0;
11254
11255 return s32Ret;
11256 }
11257
HAL_AUDIO_PCM_R2Dma_Reader1_Open(void * pData)11258 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Open(void *pData)
11259 {
11260 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11261 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11262 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
11263 MS_U32 u32TargetBufferAddrPa = 0;
11264 MS_U32 u32TargetBufferSize = 0;
11265 MS_U32 u32TargetChannel = 0;
11266 MS_U32 u32TargetBitWidth = 0;
11267 MS_U32 u32TargetAlignmentSize = 0;
11268 MS_S32 s32Ret = 0;
11269 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
11270
11271 if (pData == NULL)
11272 {
11273 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11274 return -A_EFAULT;
11275 }
11276
11277 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11278
11279 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11280 {
11281 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11282 return -A_EINVAL;
11283 }
11284
11285 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11286 {
11287 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
11288 return -A_EINVAL;
11289 }
11290
11291 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11292 {
11293 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11294 return -A_EINVAL;
11295 }
11296
11297 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11298 {
11299 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
11300 return -A_EINVAL;
11301 }
11302
11303 if (pUserPcmInfo->u8CaptureFlag == TRUE)
11304 {
11305 HALAUDIO_ERROR("%s: Error! Not support capture mode!\n", __FUNCTION__);
11306 return -A_EINVAL;
11307 }
11308
11309 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)
11310 {
11311 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
11312 return -A_EINVAL;
11313 }
11314
11315 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)
11316 {
11317 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
11318 return -A_EINVAL;
11319 }
11320
11321 if (pUserPcmInfo->u8MultiChFlag == TRUE)
11322 {
11323 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
11324 u32TargetChannel = 10;
11325 }
11326 else
11327 {
11328 /* stereo = 2 channels */
11329 u32TargetChannel = 2;
11330 }
11331
11332 /* calculate buffer size */
11333 u32TargetBitWidth = 16;
11334 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11335 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11336 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11337 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
11338 {
11339 HALAUDIO_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);
11340 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
11341 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11342 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
11343 }
11344
11345 /* fill in settings */
11346 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11347 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
11348 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
11349 pPcmInfo->u8ConnectFlag = TRUE;
11350 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11351 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
11352 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
11353 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
11354 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
11355 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
11356 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
11357 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
11358 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
11359 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
11360 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
11361 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
11362
11363 /* init DPGA */
11364 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x03, 0x03);
11365 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11366 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
11367 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
11368 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_R_CTRL, 0x12, 0x12);
11369
11370 /* init PCM buffer address */
11371 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR1_BUF_ADDR;
11372 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
11373 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
11374 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11375
11376 /* switch R2_DMA & DPGA control to MCU */
11377 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x8000);
11378 HAL_AUR2_WriteMaskReg(R2_DMARDR1_EN, 0x0001, 0x0001);
11379
11380 /* set PCM buffer address */
11381 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
11382 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
11383
11384 /* apply setting */
11385 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11386
11387 /* restart */
11388 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11389
11390 /* TODO : force channel 1~4 to decoder1 when multi-channel output is configured, it's a hardcode */
11391 if (pPcmInfo->u8MultiChFlag == TRUE)
11392 {
11393 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
11394 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
11395 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
11396 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
11397 }
11398
11399 return s32Ret;
11400 }
11401
HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)11402 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)
11403 {
11404 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11405 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11406 MS_S32 s32Ret = 0;
11407 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11408
11409 if (pPcmInfo->u8ConnectFlag != FALSE)
11410 {
11411 HAL_AUDIO_PCM_R2Dma_Reader1_Flush();
11412 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11413 }
11414
11415 /* Switch R2_DMA & DPGA control to R2 */
11416 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x0000);
11417 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x01, 0x00);
11418
11419 return s32Ret;
11420 }
11421
HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)11422 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)
11423 {
11424 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11425 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11426 MS_S32 s32Ret = 0;
11427 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11428
11429 if (pPcmInfo->u8StartFlag == FALSE)
11430 {
11431 if (pPCM->u8SettingChangeFlag == TRUE)
11432 {
11433 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
11434 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
11435 }
11436
11437 /* enable engine's MIU access */
11438 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0001);
11439
11440 pPcmInfo->u8StartFlag = TRUE;
11441 }
11442
11443 return s32Ret;
11444 }
11445
HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)11446 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)
11447 {
11448 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11449 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11450 MS_S32 s32Ret = 0;
11451 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
11452
11453 if (pPcmInfo->u8StartFlag != FALSE)
11454 {
11455 /* disable engine's MIU access */
11456 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0000);
11457
11458 pPcmInfo->u8StartFlag = FALSE;
11459 }
11460
11461 return s32Ret;
11462 }
11463
HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd,const void * pData)11464 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
11465 {
11466 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11467 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11468 MS_S32 s32Ret = 0;
11469 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11470
11471 if (pData == NULL)
11472 {
11473 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11474 return -A_EFAULT;
11475 }
11476
11477 if (pPcmInfo->u8ConnectFlag == FALSE)
11478 {
11479 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11480 return -A_EPERM;
11481 }
11482
11483 switch(u32Cmd)
11484 {
11485 case AUDIO_PCM_CMD_NONBLOCKING:
11486 {
11487 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
11488
11489 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
11490 {
11491 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
11492 s32Ret = -A_EINVAL;
11493 break;
11494 }
11495
11496 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
11497
11498 break;
11499 }
11500
11501 case AUDIO_PCM_CMD_MULTICH:
11502 {
11503 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
11504
11505 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
11506 {
11507 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
11508 s32Ret = -A_EINVAL;
11509 break;
11510 }
11511
11512 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11513 {
11514 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11515 s32Ret = -A_EINVAL;
11516 break;
11517 }
11518
11519 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
11520
11521 break;
11522 }
11523
11524 case AUDIO_PCM_CMD_MIXING:
11525 {
11526 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
11527
11528 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
11529 {
11530 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
11531 s32Ret = -A_EINVAL;
11532 break;
11533 }
11534
11535 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11536 {
11537 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
11538 s32Ret = -A_EINVAL;
11539 break;
11540 }
11541
11542 pPcmInfo->u8MixingFlag = FALSE;
11543
11544 break;
11545 }
11546
11547 case AUDIO_PCM_CMD_MIXINGGROUP:
11548 {
11549 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
11550
11551 pPcmInfo->u32MixingGroup = u32MixingGroup;
11552
11553 break;
11554 }
11555
11556 case AUDIO_PCM_CMD_BUFFERDURATION:
11557 {
11558 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
11559
11560 if (u32BufferDuration == 0)
11561 {
11562 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
11563 s32Ret = -A_EINVAL;
11564 break;
11565 }
11566
11567 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
11568 {
11569 pPcmInfo->u32BufferDuration = u32BufferDuration;
11570 pPCM->u8SettingChangeFlag = TRUE;
11571 }
11572
11573 break;
11574 }
11575
11576 case AUDIO_PCM_CMD_CHANNEL:
11577 {
11578 MS_U32 u32Channel = *((MS_U32 *)pData);
11579
11580 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11581 {
11582 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
11583 return -A_EINVAL;
11584 }
11585
11586 if (pPcmInfo->u32Channel != u32Channel)
11587 {
11588 pPcmInfo->u32Channel = u32Channel;
11589 pPCM->u8SettingChangeFlag = TRUE;
11590 }
11591
11592 break;
11593 }
11594
11595 case AUDIO_PCM_CMD_SAMPLERATE:
11596 {
11597 MS_U32 u32SampleRate = *((MS_U32 *)pData);
11598
11599 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
11600 {
11601 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
11602 return -A_EINVAL;
11603 }
11604
11605 if (pPcmInfo->u32SampleRate != u32SampleRate)
11606 {
11607 pPcmInfo->u32SampleRate = u32SampleRate;
11608 pPCM->u8SettingChangeFlag = TRUE;
11609 }
11610
11611 break;
11612 }
11613
11614 case AUDIO_PCM_CMD_BITWIDTH:
11615 {
11616 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11617
11618 pPcmInfo->u32BitWidth = u32BitWidth;
11619
11620 break;
11621 }
11622
11623 case AUDIO_PCM_CMD_BIGENDIAN:
11624 {
11625 MS_U32 u32BigEndian = *((MS_U32 *)pData);
11626
11627 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
11628 {
11629 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
11630 return -A_EINVAL;
11631 }
11632
11633 pPcmInfo->u32BigEndian = u32BigEndian;
11634
11635 break;
11636 }
11637
11638 case AUDIO_PCM_CMD_TIMESTAMP:
11639 {
11640 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11641
11642 pPcmInfo->u32Timestamp = u32Timestamp;
11643
11644 break;
11645 }
11646
11647 case AUDIO_PCM_CMD_WEIGHTING:
11648 {
11649 MS_U32 u32Weighting = *((MS_U32 *)pData);
11650
11651 if (u32Weighting > 100)
11652 {
11653 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
11654 return -A_EINVAL;
11655 }
11656
11657 pPcmInfo->u32Weighting = u32Weighting;
11658
11659 break;
11660 }
11661
11662 case AUDIO_PCM_CMD_VOLUME:
11663 {
11664 MS_U32 u32Volume = *((MS_U32 *)pData);
11665
11666 if (u32Volume > 100)
11667 {
11668 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
11669 return -A_EINVAL;
11670 }
11671
11672 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
11673
11674 break;
11675 }
11676
11677 case AUDIO_PCM_CMD_MUTE:
11678 {
11679 MS_U32 u32Mute = *((MS_U32*)pData);
11680
11681 if (u32Mute == TRUE)
11682 {
11683 pPcmInfo->u32Volume |= 0x80000000;
11684 }
11685 else if (u32Mute == FALSE)
11686 {
11687 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11688 }
11689 else
11690 {
11691 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
11692 s32Ret = -A_EINVAL;
11693 }
11694 break;
11695 }
11696
11697 default:
11698 {
11699 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11700 break;
11701 }
11702 }
11703
11704 return s32Ret;
11705 }
11706
HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd,void * pData)11707 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd, void *pData)
11708 {
11709 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11710 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11711 MS_S32 s32Ret = 0;
11712 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11713
11714 if (pData == NULL)
11715 {
11716 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11717 return -A_EFAULT;
11718 }
11719
11720 if (pPcmInfo->u8ConnectFlag == FALSE)
11721 {
11722 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11723 return -A_EPERM;
11724 }
11725
11726 switch(u32Cmd)
11727 {
11728 case AUDIO_PCM_CMD_ALL:
11729 {
11730 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11731 MS_U32 u32MinSize = 0;
11732
11733 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11734 {
11735 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11736 s32Ret = -A_EINVAL;
11737 break;
11738 }
11739 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
11740 {
11741 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11742 }
11743
11744 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
11745 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
11746 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
11747
11748 break;
11749 }
11750
11751 case AUDIO_PCM_CMD_NONBLOCKING:
11752 {
11753 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11754 break;
11755 }
11756
11757 case AUDIO_PCM_CMD_MULTICH:
11758 {
11759 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11760 break;
11761 }
11762
11763 case AUDIO_PCM_CMD_MIXING:
11764 {
11765 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11766 break;
11767 }
11768
11769 case AUDIO_PCM_CMD_MIXINGGROUP:
11770 {
11771 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11772 break;
11773 }
11774
11775 case AUDIO_PCM_CMD_BUFFER:
11776 {
11777 /*
11778 * TODO, need better coding
11779 *
11780 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
11781 */
11782 break;
11783 }
11784
11785 case AUDIO_PCM_CMD_BUFFERDURATION:
11786 {
11787 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11788 break;
11789 }
11790
11791 case AUDIO_PCM_CMD_READPTR:
11792 {
11793 /*
11794 * TODO, need better coding
11795 *
11796 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
11797 */
11798 break;
11799 }
11800
11801 case AUDIO_PCM_CMD_WRITEPTR:
11802 {
11803 /*
11804 * TODO, need better coding
11805 *
11806 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
11807 */
11808 break;
11809 }
11810
11811 case AUDIO_PCM_CMD_CHANNEL:
11812 {
11813 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11814 break;
11815 }
11816
11817 case AUDIO_PCM_CMD_SAMPLERATE:
11818 {
11819 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11820 break;
11821 }
11822
11823 case AUDIO_PCM_CMD_BITWIDTH:
11824 {
11825 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11826 break;
11827 }
11828
11829 case AUDIO_PCM_CMD_BIGENDIAN:
11830 {
11831 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
11832 break;
11833 }
11834
11835 case AUDIO_PCM_CMD_TIMESTAMP:
11836 {
11837 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11838 break;
11839 }
11840
11841 case AUDIO_PCM_CMD_WEIGHTING:
11842 {
11843 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11844 break;
11845 }
11846
11847 case AUDIO_PCM_CMD_VOLUME:
11848 {
11849 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
11850 break;
11851 }
11852
11853 case AUDIO_PCM_CMD_BUFFERLEVEL:
11854 {
11855 MS_U32 u32BufferLevel1 = 0;
11856 MS_U32 u32BufferLevel2 = 0;
11857 MS_U32 u32Timeout = 20;
11858
11859 while (u32Timeout > 0)
11860 {
11861 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
11862 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
11863
11864 if (u32BufferLevel1 == u32BufferLevel2)
11865 {
11866 break;
11867 }
11868
11869 u32Timeout--;
11870
11871 #ifdef MSOS_TYPE_LINUX_KERNEL
11872 udelay(1);
11873 #else
11874 AUDIO_DELAY1US(1);
11875 #endif
11876 }
11877
11878 if (u32BufferLevel1 != u32BufferLevel2)
11879 {
11880 HALAUDIO_ERROR("%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
11881 }
11882
11883 pPcmInfo->u32BufferLevel = u32BufferLevel2;
11884 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11885
11886 break;
11887 }
11888
11889 case AUDIO_PCM_CMD_MUTE:
11890 {
11891 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11892 break;
11893 }
11894
11895 case AUDIO_PCM_CMD_BUFFERSIZE:
11896 {
11897 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
11898 break;
11899 }
11900
11901 default:
11902 {
11903 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11904 break;
11905 }
11906 }
11907
11908 return s32Ret;
11909 }
11910
HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void * pBuf,MS_U32 u32Size)11911 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
11912 {
11913 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
11914 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11915 MS_S8 *pBufTmp = NULL;
11916 MS_U32 u32BufferSize = 0;
11917 MS_U32 u32PcmLevel = 0;
11918 MS_U32 u32RequestSize = 0;
11919 MS_U32 u32RequestSizeTmp = 0;
11920 MS_U32 u32SizeToCopy = 0;
11921 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11922
11923 if (pBuf == NULL)
11924 {
11925 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11926 return 0;
11927 }
11928
11929 if (u32Size == 0)
11930 {
11931 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
11932 return 0;
11933 }
11934
11935 if (pPcmInfo->u8ConnectFlag == FALSE)
11936 {
11937 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11938 return 0;
11939 }
11940
11941 if (pPcmInfo->u8StartFlag == FALSE)
11942 {
11943 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
11944 return 0;
11945 }
11946
11947 /*
11948 * A patch here!
11949 * to ensure channel 1~4 are configured as decoder1
11950 */
11951 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x80) ||
11952 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x80) ||
11953 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x80) ||
11954 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x80))
11955 {
11956 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
11957 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
11958 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
11959 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
11960 }
11961
11962 pBufTmp = (MS_S8 *)pBuf;
11963
11964 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
11965 if (u32PcmLevel == 0)
11966 {
11967 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11968 }
11969
11970 u32RequestSize = u32Size;
11971 u32RequestSizeTmp = u32RequestSize;
11972
11973 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
11974
11975 /* copy data to PCM buffer */
11976 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
11977 {
11978 do {
11979 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
11980 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11981
11982 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11983
11984 pBufTmp += u32SizeToCopy;
11985 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
11986 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
11987 {
11988 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
11989 {
11990 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11991 }
11992 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11993 }
11994
11995 u32RequestSizeTmp -= u32SizeToCopy;
11996 } while (u32RequestSizeTmp > 0);
11997
11998 /* flush MIU */
11999 MsOS_FlushMemory();
12000
12001 /* update copied size to engine */
12002 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
12003 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
12004 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0400);
12005 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0000);
12006 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
12007
12008 return u32Size;
12009 }
12010
12011 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
12012
12013 return 0;
12014 }
12015
HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)12016 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)
12017 {
12018 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12019 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12020 MS_S32 s32Ret = 0;
12021 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12022
12023 if (pPcmInfo->u8StartFlag == FALSE)
12024 {
12025 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
12026 HAL_AUDIO_PCM_R2Dma_Reader1_Stop();
12027 }
12028
12029 return s32Ret;
12030 }
12031 #endif
12032
12033 #if AUDIO_R2_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)12034 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)
12035 {
12036 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12037 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12038 MS_U16 u16Val = 0;
12039 MS_U16 u16Synthrate_H = 0;
12040 MS_U16 u16Synthrate_L = 0;
12041 MS_U32 u32TargetBufferSize = 0;
12042 MS_U32 u32TargetChannel = 0;
12043 MS_U32 u32TargetBitWidth = 0;
12044 MS_U32 u32TargetAlignmentSize = 0;
12045 MS_S32 s32Ret = 0;
12046
12047 switch(pPcmInfo->u32SampleRate) {
12048 case 8000:
12049 {
12050 u16Synthrate_H = 0x6978;
12051 u16Synthrate_L = 0x0000;
12052 break;
12053 }
12054
12055 case 11025:
12056 {
12057 u16Synthrate_H = 0x4C87;
12058 u16Synthrate_L = 0xD634;
12059 break;
12060 }
12061
12062 case 12000:
12063 {
12064 u16Synthrate_H = 0x4650;
12065 u16Synthrate_L = 0x0000;
12066 break;
12067 }
12068
12069 case 16000:
12070 {
12071 u16Synthrate_H = 0x34BC;
12072 u16Synthrate_L = 0x0000;
12073 break;
12074 }
12075
12076 case 22050:
12077 {
12078 u16Synthrate_H = 0x2643;
12079 u16Synthrate_L = 0xEB1A;
12080 break;
12081 }
12082
12083 case 24000:
12084 {
12085 u16Synthrate_H = 0x2328;
12086 u16Synthrate_L = 0x0000;
12087 break;
12088 }
12089
12090 case 32000:
12091 {
12092 u16Synthrate_H = 0x1A5E;
12093 u16Synthrate_L = 0x0000;
12094 break;
12095 }
12096
12097 case 44100:
12098 {
12099 u16Synthrate_H = 0x1321;
12100 u16Synthrate_L = 0xF58D;
12101 break;
12102 }
12103
12104 case 48000:
12105 {
12106 u16Synthrate_H = 0x1194;
12107 u16Synthrate_L = 0x0000;
12108 break;
12109 }
12110
12111 case 96000:
12112 {
12113 u16Synthrate_H = 0x08CA;
12114 u16Synthrate_L = 0x0000;
12115 break;
12116 }
12117
12118 default:
12119 {
12120 u16Synthrate_H = 0x1194;
12121 u16Synthrate_L = 0x0000;
12122 pPcmInfo->u32SampleRate = 48000;
12123 break;
12124 }
12125 }
12126
12127 /* disable output */
12128 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x7FFF, 0x0000);
12129
12130 /* set synthesizer */
12131 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
12132 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
12133 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12134 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0404); /* SYTH3 bit10 RIU control, bit3 update */
12135 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
12136
12137 if (pPcmInfo->u8MultiChFlag == TRUE)
12138 {
12139 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12140 u32TargetChannel = 10;
12141 }
12142 else
12143 {
12144 /* stereo = 2 channels */
12145 u32TargetChannel = 2;
12146 }
12147
12148 /* calculate buffer size */
12149 u32TargetBitWidth = 16;
12150 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12151 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12152 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12153 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12154 {
12155 HALAUDIO_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);
12156 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12157 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12158 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
12159 }
12160
12161 /* set buffer size */
12162 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
12163
12164 /* set overrun & underrun threshold */
12165 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize>> 3)) / BYTES_IN_MIU_LINE));
12166 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
12167
12168 /* set channel mode */
12169 if (pPcmInfo->u8MultiChFlag == TRUE)
12170 {
12171 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12172 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x00);
12173 u16Val = 19; /* MIU burst length = 19 */
12174 u16Val += (1 << 7); /* MIU Step En = 1 */
12175 u16Val += (1 << 15); /* Sync Valid En = 1 */
12176 u16Val += (1 << 8); /* Sync Step Count = 1 */
12177 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12178 }
12179 else
12180 {
12181 /* Stereo mode : stereo = 2 channels */
12182 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x80);
12183 u16Val = 3; /* MIU burst length = 3 */
12184 u16Val += (0 << 7); /* MIU Step En = 0 */
12185 u16Val += (0 << 15); /* Sync Valid En = 0 */
12186 u16Val += (1 << 8); /* Sync Step Count = 1 */
12187 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
12188 }
12189
12190 /* set 16 Bit mode */
12191 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0860, 0x0020);
12192
12193 pPCM->u8SettingChangeFlag = FALSE;
12194
12195 return s32Ret;
12196 }
12197
HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)12198 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)
12199 {
12200 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12201 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12202 MS_S32 s32Ret = 0;
12203
12204 if (pPcmInfo->u8ConnectFlag == FALSE)
12205 {
12206 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12207 return -A_EPERM;
12208 }
12209
12210 /* stop engine */
12211 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0000);
12212
12213 /* clear PCM buffer */
12214 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR2_BUF_SIZE);
12215
12216 /* flush MIU */
12217 MsOS_FlushMemory();
12218
12219 /* initial dlocal buffer */
12220 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x2000);
12221 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x0000);
12222
12223 /* reset engine */
12224 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x1000);
12225 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x0000);
12226
12227 /* start engine */
12228 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0002);
12229
12230 /* reset write pointer */
12231 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12232
12233 /* reset remain size */
12234 pPCM->tPcmBufferInfo.u32RemainSize = 0;
12235
12236 return s32Ret;
12237 }
12238
HAL_AUDIO_PCM_R2Dma_Reader2_Open(void * pData)12239 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Open(void *pData)
12240 {
12241 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12242 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12243 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
12244 MS_U32 u32TargetBufferAddrPa = 0;
12245 MS_U32 u32TargetBufferSize = 0;
12246 MS_U32 u32TargetChannel = 0;
12247 MS_U32 u32TargetBitWidth = 0;
12248 MS_U32 u32TargetAlignmentSize = 0;
12249 MS_S32 s32Ret = 0;
12250 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
12251
12252 if (pData == NULL)
12253 {
12254 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12255 return -A_EFAULT;
12256 }
12257
12258 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12259
12260 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12261 {
12262 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12263 return -A_EINVAL;
12264 }
12265
12266 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12267 {
12268 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
12269 return -A_EINVAL;
12270 }
12271
12272 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12273 {
12274 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12275 return -A_EINVAL;
12276 }
12277
12278 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12279 {
12280 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
12281 return -A_EINVAL;
12282 }
12283
12284 if (pUserPcmInfo->u8CaptureFlag == TRUE)
12285 {
12286 HALAUDIO_ERROR("%s: Error! Not support capture mode!\n", __FUNCTION__);
12287 return -A_EINVAL;
12288 }
12289
12290 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)
12291 {
12292 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
12293 return -A_EINVAL;
12294 }
12295
12296 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)
12297 {
12298 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
12299 return -A_EINVAL;
12300 }
12301
12302 if (pUserPcmInfo->u8MultiChFlag == TRUE)
12303 {
12304 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12305 u32TargetChannel = 10;
12306 }
12307 else
12308 {
12309 /* stereo = 2 channels */
12310 u32TargetChannel = 2;
12311 }
12312
12313 /* calculate buffer size */
12314 u32TargetBitWidth = 16;
12315 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12316 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12317 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12318 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
12319 {
12320 HALAUDIO_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);
12321 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
12322 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12323 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
12324 }
12325
12326 /* fill in settings */
12327 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12328 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
12329 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
12330 pPcmInfo->u8ConnectFlag = TRUE;
12331 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12332 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
12333 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
12334 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
12335 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
12336 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
12337 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
12338 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
12339 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
12340 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
12341 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
12342 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
12343
12344 /* init DPGA */
12345 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x03, 0x03);
12346 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12347 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12348 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
12349 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_R_CTRL, 0x12, 0x12);
12350
12351 /* init PCM buffer address */
12352 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR2_BUF_ADDR;
12353 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
12354 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
12355 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12356
12357 /* switch R2_DMA & DPGA control to MCU */
12358 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x8000);
12359 HAL_AUR2_WriteMaskReg(R2_DMARDR2_EN, 0x0001, 0x0001);
12360
12361 /* set PCM buffer address */
12362 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
12363 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
12364
12365 /* apply setting */
12366 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12367
12368 /* restart */
12369 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12370
12371 /* TODO : force channel 1~4 to decoder3 when multi-channel output is configured, it's a hardcode */
12372 if (pPcmInfo->u8MultiChFlag == TRUE)
12373 {
12374 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
12375 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
12376 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
12377 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
12378 }
12379
12380 return s32Ret;
12381 }
12382
HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)12383 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)
12384 {
12385 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12386 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12387 MS_S32 s32Ret = 0;
12388 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
12389
12390 if (pPcmInfo->u8ConnectFlag != FALSE)
12391 {
12392 HAL_AUDIO_PCM_R2Dma_Reader2_Flush();
12393 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12394 }
12395
12396 /* switch R2_DMA & DPGA control to R2 */
12397 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x0000);
12398 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x01, 0x00);
12399
12400 return s32Ret;
12401 }
12402
HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)12403 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)
12404 {
12405 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12406 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12407 MS_S32 s32Ret = 0;
12408 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
12409
12410 if (pPcmInfo->u8StartFlag == FALSE)
12411 {
12412 if (pPCM->u8SettingChangeFlag == TRUE)
12413 {
12414 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
12415 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
12416 }
12417
12418 /* enable engine's MIU access */
12419 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0001);
12420
12421 pPcmInfo->u8StartFlag = TRUE;
12422 }
12423
12424 return s32Ret;
12425 }
12426
HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)12427 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)
12428 {
12429 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12430 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12431 MS_S32 s32Ret = 0;
12432 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
12433
12434 if (pPcmInfo->u8StartFlag != FALSE)
12435 {
12436 /* disable engine's MIU access */
12437 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0000);
12438
12439 pPcmInfo->u8StartFlag = FALSE;
12440 }
12441
12442 return s32Ret;
12443 }
12444
HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd,const void * pData)12445 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
12446 {
12447 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12448 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12449 MS_S32 s32Ret = 0;
12450 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12451
12452 if (pData == NULL)
12453 {
12454 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12455 return -A_EFAULT;
12456 }
12457
12458 if (pPcmInfo->u8ConnectFlag == FALSE)
12459 {
12460 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12461 return -A_EPERM;
12462 }
12463
12464 switch(u32Cmd)
12465 {
12466 case AUDIO_PCM_CMD_NONBLOCKING:
12467 {
12468 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
12469
12470 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
12471 {
12472 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
12473 s32Ret = -A_EINVAL;
12474 break;
12475 }
12476
12477 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
12478
12479 break;
12480 }
12481
12482 case AUDIO_PCM_CMD_MULTICH:
12483 {
12484 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
12485
12486 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
12487 {
12488 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
12489 s32Ret = -A_EINVAL;
12490 break;
12491 }
12492
12493 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12494 {
12495 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12496 s32Ret = -A_EINVAL;
12497 break;
12498 }
12499
12500 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
12501
12502 break;
12503 }
12504
12505 case AUDIO_PCM_CMD_MIXING:
12506 {
12507 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
12508
12509 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
12510 {
12511 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
12512 s32Ret = -A_EINVAL;
12513 break;
12514 }
12515
12516 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12517 {
12518 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
12519 s32Ret = -A_EINVAL;
12520 break;
12521 }
12522
12523 pPcmInfo->u8MixingFlag = FALSE;
12524
12525 break;
12526 }
12527
12528 case AUDIO_PCM_CMD_MIXINGGROUP:
12529 {
12530 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
12531
12532 pPcmInfo->u32MixingGroup = u32MixingGroup;
12533
12534 break;
12535 }
12536
12537 case AUDIO_PCM_CMD_BUFFERDURATION:
12538 {
12539 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
12540
12541 if (u32BufferDuration == 0)
12542 {
12543 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
12544 s32Ret = -A_EINVAL;
12545 break;
12546 }
12547
12548 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
12549 {
12550 pPcmInfo->u32BufferDuration = u32BufferDuration;
12551 pPCM->u8SettingChangeFlag = TRUE;
12552 }
12553
12554 break;
12555 }
12556
12557 case AUDIO_PCM_CMD_CHANNEL:
12558 {
12559 MS_U32 u32Channel = *((MS_U32 *)pData);
12560
12561 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12562 {
12563 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
12564 return -A_EINVAL;
12565 }
12566
12567 if (pPcmInfo->u32Channel != u32Channel)
12568 {
12569 pPcmInfo->u32Channel = u32Channel;
12570 pPCM->u8SettingChangeFlag = TRUE;
12571 }
12572
12573 break;
12574 }
12575
12576 case AUDIO_PCM_CMD_SAMPLERATE:
12577 {
12578 MS_U32 u32SampleRate = *((MS_U32 *)pData);
12579
12580 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12581 {
12582 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
12583 return -A_EINVAL;
12584 }
12585
12586 if (pPcmInfo->u32SampleRate != u32SampleRate)
12587 {
12588 pPcmInfo->u32SampleRate = u32SampleRate;
12589 pPCM->u8SettingChangeFlag = TRUE;
12590 }
12591
12592 break;
12593 }
12594
12595 case AUDIO_PCM_CMD_BITWIDTH:
12596 {
12597 MS_U32 u32BitWidth = *((MS_U32 *)pData);
12598
12599 pPcmInfo->u32BitWidth = u32BitWidth;
12600
12601 break;
12602 }
12603
12604 case AUDIO_PCM_CMD_BIGENDIAN:
12605 {
12606 MS_U32 u32BigEndian = *((MS_U32 *)pData);
12607
12608 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
12609 {
12610 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
12611 return -A_EINVAL;
12612 }
12613
12614 pPcmInfo->u32BigEndian = u32BigEndian;
12615
12616 break;
12617 }
12618
12619 case AUDIO_PCM_CMD_TIMESTAMP:
12620 {
12621 MS_U32 u32Timestamp = *((MS_U32 *)pData);
12622
12623 pPcmInfo->u32Timestamp = u32Timestamp;
12624
12625 break;
12626 }
12627
12628 case AUDIO_PCM_CMD_WEIGHTING:
12629 {
12630 MS_U32 u32Weighting = *((MS_U32 *)pData);
12631
12632 if (u32Weighting > 100)
12633 {
12634 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
12635 return -A_EINVAL;
12636 }
12637
12638 pPcmInfo->u32Weighting = u32Weighting;
12639
12640 break;
12641 }
12642
12643 case AUDIO_PCM_CMD_VOLUME:
12644 {
12645 MS_U32 u32Volume = *((MS_U32 *)pData);
12646
12647 if (u32Volume > 100)
12648 {
12649 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
12650 return -A_EINVAL;
12651 }
12652
12653 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
12654
12655 break;
12656 }
12657
12658 case AUDIO_PCM_CMD_MUTE:
12659 {
12660 MS_U32 u32Mute = *((MS_U32*)pData);
12661
12662 if (u32Mute == TRUE)
12663 {
12664 pPcmInfo->u32Volume |= 0x80000000;
12665 }
12666 else if (u32Mute == FALSE)
12667 {
12668 pPcmInfo->u32Volume &= 0x7FFFFFFF;
12669 }
12670 else
12671 {
12672 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
12673 s32Ret = -A_EINVAL;
12674 }
12675 break;
12676 }
12677
12678 default:
12679 {
12680 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12681 break;
12682 }
12683 }
12684
12685 return s32Ret;
12686 }
12687
HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd,void * pData)12688 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd, void *pData)
12689 {
12690 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12691 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12692 MS_S32 s32Ret = 0;
12693 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12694
12695 if (pData == NULL)
12696 {
12697 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12698 return -A_EFAULT;
12699 }
12700
12701 if (pPcmInfo->u8ConnectFlag == FALSE)
12702 {
12703 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12704 return -A_EPERM;
12705 }
12706
12707 switch(u32Cmd)
12708 {
12709 case AUDIO_PCM_CMD_ALL:
12710 {
12711 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12712 MS_U32 u32MinSize = 0;
12713
12714 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12715 {
12716 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12717 s32Ret = -A_EINVAL;
12718 break;
12719 }
12720 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
12721 {
12722 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12723 }
12724
12725 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
12726 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
12727 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
12728
12729 break;
12730 }
12731
12732 case AUDIO_PCM_CMD_NONBLOCKING:
12733 {
12734 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
12735 break;
12736 }
12737
12738 case AUDIO_PCM_CMD_MULTICH:
12739 {
12740 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
12741 break;
12742 }
12743
12744 case AUDIO_PCM_CMD_MIXING:
12745 {
12746 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
12747 break;
12748 }
12749
12750 case AUDIO_PCM_CMD_MIXINGGROUP:
12751 {
12752 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
12753 break;
12754 }
12755
12756 case AUDIO_PCM_CMD_BUFFER:
12757 {
12758 /*
12759 * TODO, need better coding
12760 *
12761 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
12762 */
12763 break;
12764 }
12765
12766 case AUDIO_PCM_CMD_BUFFERDURATION:
12767 {
12768 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
12769 break;
12770 }
12771
12772 case AUDIO_PCM_CMD_READPTR:
12773 {
12774 /*
12775 * TODO, need better coding
12776 *
12777 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
12778 */
12779 break;
12780 }
12781
12782 case AUDIO_PCM_CMD_WRITEPTR:
12783 {
12784 /*
12785 * TODO, need better coding
12786 *
12787 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
12788 */
12789 break;
12790 }
12791
12792 case AUDIO_PCM_CMD_CHANNEL:
12793 {
12794 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
12795 break;
12796 }
12797
12798 case AUDIO_PCM_CMD_SAMPLERATE:
12799 {
12800 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
12801 break;
12802 }
12803
12804 case AUDIO_PCM_CMD_BITWIDTH:
12805 {
12806 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
12807 break;
12808 }
12809
12810 case AUDIO_PCM_CMD_BIGENDIAN:
12811 {
12812 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
12813 break;
12814 }
12815
12816 case AUDIO_PCM_CMD_TIMESTAMP:
12817 {
12818 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
12819 break;
12820 }
12821
12822 case AUDIO_PCM_CMD_WEIGHTING:
12823 {
12824 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
12825 break;
12826 }
12827
12828 case AUDIO_PCM_CMD_VOLUME:
12829 {
12830 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
12831 break;
12832 }
12833
12834 case AUDIO_PCM_CMD_BUFFERLEVEL:
12835 {
12836 MS_U32 u32BufferLevel1 = 0;
12837 MS_U32 u32BufferLevel2 = 0;
12838 MS_U32 u32Timeout = 20;
12839
12840 while (u32Timeout > 0)
12841 {
12842 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12843 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12844
12845 if (u32BufferLevel1 == u32BufferLevel2)
12846 {
12847 break;
12848 }
12849
12850 u32Timeout--;
12851
12852 #ifdef MSOS_TYPE_LINUX_KERNEL
12853 udelay(1);
12854 #else
12855 AUDIO_DELAY1US(1);
12856 #endif
12857 }
12858
12859 if (u32BufferLevel1 != u32BufferLevel2)
12860 {
12861 HALAUDIO_ERROR("%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
12862 }
12863
12864 pPcmInfo->u32BufferLevel = u32BufferLevel2;
12865 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12866
12867 break;
12868 }
12869
12870 case AUDIO_PCM_CMD_MUTE:
12871 {
12872 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12873 break;
12874 }
12875
12876 case AUDIO_PCM_CMD_BUFFERSIZE:
12877 {
12878 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
12879 break;
12880 }
12881
12882 default:
12883 {
12884 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12885 break;
12886 }
12887 }
12888
12889 return s32Ret;
12890 }
12891
HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void * pBuf,MS_U32 u32Size)12892 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
12893 {
12894 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
12895 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12896 MS_S8 *pBufTmp = NULL;
12897 MS_U32 u32BufferSize = 0;
12898 MS_U32 u32PcmLevel = 0;
12899 MS_U32 u32RequestSize = 0;
12900 MS_U32 u32RequestSizeTmp = 0;
12901 MS_U32 u32SizeToCopy = 0;
12902 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
12903
12904 if (pBuf == NULL)
12905 {
12906 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
12907 return 0;
12908 }
12909
12910 if (u32Size == 0)
12911 {
12912 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
12913 return 0;
12914 }
12915
12916 if (pPcmInfo->u8ConnectFlag == FALSE)
12917 {
12918 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12919 return 0;
12920 }
12921
12922 if (pPcmInfo->u8StartFlag == FALSE)
12923 {
12924 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
12925 return 0;
12926 }
12927
12928 /*
12929 * A patch here!
12930 * to ensure channel 1~4 are configured as decoder3
12931 */
12932 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x82) ||
12933 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x82) ||
12934 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x82) ||
12935 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x82))
12936 {
12937 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
12938 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
12939 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
12940 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
12941 }
12942
12943 pBufTmp = (MS_S8 *)pBuf;
12944
12945 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12946 if (u32PcmLevel == 0)
12947 {
12948 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
12949 }
12950
12951 u32RequestSize = u32Size;
12952 u32RequestSizeTmp = u32RequestSize;
12953
12954 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
12955
12956 /* copy data to PCM buffer */
12957 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
12958 {
12959 do {
12960 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
12961 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12962
12963 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12964
12965 pBufTmp += u32SizeToCopy;
12966 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
12967 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12968 {
12969 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
12970 {
12971 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12972 }
12973 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12974 }
12975
12976 u32RequestSizeTmp -= u32SizeToCopy;
12977 } while (u32RequestSizeTmp > 0);
12978
12979 /* flush MIU */
12980 MsOS_FlushMemory();
12981
12982 /* update copied size to engine */
12983 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
12984 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
12985 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0400);
12986 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0000);
12987 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
12988
12989 return u32Size;
12990 }
12991
12992 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
12993
12994 return 0;
12995 }
12996
HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)12997 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)
12998 {
12999 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13000 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13001 MS_S32 s32Ret = 0;
13002 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13003
13004 if (pPcmInfo->u8StartFlag == FALSE)
13005 {
13006 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
13007 HAL_AUDIO_PCM_R2Dma_Reader2_Stop();
13008 }
13009
13010 return s32Ret;
13011 }
13012 #endif
13013
13014 #if AUDIO_PCM_CAPTURE1_SUPPORT
HAL_AUDIO_PCM_Capture1_Restart(void)13015 MS_S32 HAL_AUDIO_PCM_Capture1_Restart(void)
13016 {
13017 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13018 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13019 MS_U32 u32WritePtrOffset = 0;
13020 MS_U32 u32TimeoutCounter = 0;
13021 MS_S32 s32Ret = 0;
13022
13023 if (pPcmInfo->u8ConnectFlag == FALSE)
13024 {
13025 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13026 return -A_EPERM;
13027 }
13028
13029 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0x0000);
13030
13031 do {
13032 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13033
13034 if (u32WritePtrOffset != 0)
13035 {
13036 #ifdef MSOS_TYPE_LINUX_KERNEL
13037 udelay(50);
13038 #else
13039 AUDIO_DELAY1US(50);
13040 #endif
13041 u32TimeoutCounter++;
13042 }
13043 else
13044 {
13045 break;
13046 }
13047 } while (u32TimeoutCounter < 10000);
13048
13049 /* clear PCM buffer */
13050 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE1_BUF_SIZE);
13051
13052 /* flush MIU */
13053 MsOS_FlushMemory();
13054
13055 /* reset PCM capture1 read & write pointer */
13056 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13057 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13058 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0x0000);
13059
13060 return s32Ret;
13061 }
13062
HAL_AUDIO_PCM_Capture1_Open(void * pData)13063 MS_S32 HAL_AUDIO_PCM_Capture1_Open(void *pData)
13064 {
13065 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13066 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13067 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13068 MS_U32 u32TargetBufferAddrPa = 0;
13069 MS_S32 s32Ret = 0;
13070 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13071
13072 if (pData == NULL)
13073 {
13074 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
13075 return -A_EFAULT;
13076 }
13077
13078 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13079
13080 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13081 {
13082 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13083 return -A_EINVAL;
13084 }
13085
13086 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13087 {
13088 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
13089 return -A_EINVAL;
13090 }
13091
13092 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13093 {
13094 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13095 return -A_EINVAL;
13096 }
13097
13098 if (pUserPcmInfo->u8MixingFlag == TRUE)
13099 {
13100 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
13101 return -A_EINVAL;
13102 }
13103
13104 if (pUserPcmInfo->u8CaptureFlag != TRUE)
13105 {
13106 HALAUDIO_ERROR("%s: Error! Not support playback mode!\n", __FUNCTION__);
13107 return -A_EINVAL;
13108 }
13109
13110 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)
13111 {
13112 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13113 return -A_EINVAL;
13114 }
13115
13116 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)
13117 {
13118 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13119 return -A_EINVAL;
13120 }
13121
13122 /* fill in settings */
13123 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13124 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13125 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13126 pPcmInfo->u8ConnectFlag = TRUE;
13127 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13128 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13129 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13130 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13131 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13132 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
13133 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
13134 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
13135 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13136 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13137 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13138 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13139
13140 /* init PCM buffer address */
13141 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
13142 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13143 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13144 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13145
13146 /* restart */
13147 HAL_AUDIO_PCM_Capture1_Restart();
13148
13149 return s32Ret;
13150 }
13151
HAL_AUDIO_PCM_Capture1_Close(void)13152 MS_S32 HAL_AUDIO_PCM_Capture1_Close(void)
13153 {
13154 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13155 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13156 MS_S32 s32Ret = 0;
13157 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13158
13159 if (pPcmInfo->u8ConnectFlag != FALSE)
13160 {
13161 HAL_AUDIO_PCM_Capture1_Flush();
13162 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13163 }
13164
13165 return s32Ret;
13166 }
13167
HAL_AUDIO_PCM_Capture1_Start(void)13168 MS_S32 HAL_AUDIO_PCM_Capture1_Start(void)
13169 {
13170 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13171 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13172 MS_U32 u32BufferSize = 0;
13173 MS_S32 s32Ret = 0;
13174 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13175
13176 if (pPcmInfo->u8StartFlag == FALSE)
13177 {
13178 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13179 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
13180
13181 pPcmInfo->u8StartFlag = TRUE;
13182 }
13183
13184 return s32Ret;
13185 }
13186
HAL_AUDIO_PCM_Capture1_Stop(void)13187 MS_S32 HAL_AUDIO_PCM_Capture1_Stop(void)
13188 {
13189 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13190 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13191 MS_S32 s32Ret = 0;
13192 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13193
13194 if (pPcmInfo->u8StartFlag != FALSE)
13195 {
13196 /* TODO, there is no such control in DSP */
13197
13198 pPcmInfo->u8StartFlag = FALSE;
13199 }
13200
13201 return s32Ret;
13202 }
13203
HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd,const void * pData)13204 MS_S32 HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd, const void *pData)
13205 {
13206 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13207 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13208 MS_S32 s32Ret = 0;
13209 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13210
13211 if (pData == NULL)
13212 {
13213 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
13214 return -A_EFAULT;
13215 }
13216
13217 if (pPcmInfo->u8ConnectFlag == FALSE)
13218 {
13219 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13220 return -A_EPERM;
13221 }
13222
13223 switch(u32Cmd)
13224 {
13225 case AUDIO_PCM_CMD_NONBLOCKING:
13226 {
13227 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13228
13229 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13230 {
13231 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13232 s32Ret = -A_EINVAL;
13233 break;
13234 }
13235
13236 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13237
13238 break;
13239 }
13240
13241 case AUDIO_PCM_CMD_MULTICH:
13242 {
13243 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13244
13245 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13246 {
13247 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13248 s32Ret = -A_EINVAL;
13249 break;
13250 }
13251
13252 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13253 {
13254 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13255 s32Ret = -A_EINVAL;
13256 break;
13257 }
13258
13259 pPcmInfo->u8MultiChFlag = FALSE;
13260
13261 break;
13262 }
13263
13264 case AUDIO_PCM_CMD_MIXING:
13265 {
13266 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13267
13268 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13269 {
13270 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13271 s32Ret = -A_EINVAL;
13272 break;
13273 }
13274
13275 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13276 {
13277 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
13278 s32Ret = -A_EINVAL;
13279 break;
13280 }
13281
13282 pPcmInfo->u8MixingFlag = FALSE;
13283
13284 break;
13285 }
13286
13287 case AUDIO_PCM_CMD_MIXINGGROUP:
13288 {
13289 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13290
13291 pPcmInfo->u32MixingGroup = u32MixingGroup;
13292
13293 break;
13294 }
13295
13296 case AUDIO_PCM_CMD_BUFFERDURATION:
13297 {
13298 HALAUDIO_ERROR("%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
13299 s32Ret = -A_EPERM;
13300
13301 break;
13302 }
13303
13304 case AUDIO_PCM_CMD_CHANNEL:
13305 {
13306 HALAUDIO_ERROR("%s: Warning! Not support to configure channel!\n", __FUNCTION__);
13307 s32Ret = -A_EPERM;
13308
13309 break;
13310 }
13311
13312 case AUDIO_PCM_CMD_SAMPLERATE:
13313 {
13314 HALAUDIO_ERROR("%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
13315 s32Ret = -A_EPERM;
13316
13317 break;
13318 }
13319
13320 case AUDIO_PCM_CMD_BITWIDTH:
13321 {
13322 MS_U32 u32BitWidth = *((MS_U32 *)pData);
13323
13324 pPcmInfo->u32BitWidth = u32BitWidth;
13325
13326 break;
13327 }
13328
13329 case AUDIO_PCM_CMD_BIGENDIAN:
13330 {
13331 MS_U32 u32BigEndian = *((MS_U32 *)pData);
13332
13333 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
13334 {
13335 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
13336 return -A_EINVAL;
13337 }
13338
13339 pPcmInfo->u32BigEndian = u32BigEndian;
13340
13341 break;
13342 }
13343
13344 case AUDIO_PCM_CMD_TIMESTAMP:
13345 {
13346 MS_U32 u32Timestamp = *((MS_U32 *)pData);
13347
13348 pPcmInfo->u32Timestamp = u32Timestamp;
13349
13350 break;
13351 }
13352
13353 case AUDIO_PCM_CMD_WEIGHTING:
13354 {
13355 MS_U32 u32Weighting = *((MS_U32 *)pData);
13356
13357 if (u32Weighting > 100)
13358 {
13359 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
13360 return -A_EINVAL;
13361 }
13362
13363 pPcmInfo->u32Weighting = u32Weighting;
13364
13365 break;
13366 }
13367
13368 case AUDIO_PCM_CMD_VOLUME:
13369 {
13370 MS_U32 u32Volume = *((MS_U32 *)pData);
13371
13372 if (u32Volume > 100)
13373 {
13374 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
13375 return -A_EINVAL;
13376 }
13377
13378 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
13379
13380 break;
13381 }
13382
13383 case AUDIO_PCM_CMD_MUTE:
13384 {
13385 MS_U32 u32Mute = *((MS_U32*)pData);
13386
13387 if (u32Mute == TRUE)
13388 {
13389 pPcmInfo->u32Volume |= 0x80000000;
13390 }
13391 else if (u32Mute == FALSE)
13392 {
13393 pPcmInfo->u32Volume &= 0x7FFFFFFF;
13394 }
13395 else
13396 {
13397 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
13398 s32Ret = -A_EINVAL;
13399 }
13400 break;
13401 }
13402
13403 default:
13404 {
13405 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13406 break;
13407 }
13408 }
13409
13410 return s32Ret;
13411 }
13412
HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd,void * pData)13413 MS_S32 HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd, void *pData)
13414 {
13415 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13416 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13417 MS_S32 s32Ret = 0;
13418 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13419
13420 if (pData == NULL)
13421 {
13422 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
13423 return -A_EFAULT;
13424 }
13425
13426 if (pPcmInfo->u8ConnectFlag == FALSE)
13427 {
13428 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13429 return -A_EPERM;
13430 }
13431
13432 switch(u32Cmd)
13433 {
13434 case AUDIO_PCM_CMD_ALL:
13435 {
13436 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13437 MS_U32 u32MinSize = 0;
13438
13439 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13440 {
13441 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13442 s32Ret = -A_EINVAL;
13443 break;
13444 }
13445 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
13446 {
13447 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13448 }
13449
13450 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
13451 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
13452 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
13453
13454 break;
13455 }
13456
13457 case AUDIO_PCM_CMD_NONBLOCKING:
13458 {
13459 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
13460 break;
13461 }
13462
13463 case AUDIO_PCM_CMD_MULTICH:
13464 {
13465 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
13466 break;
13467 }
13468
13469 case AUDIO_PCM_CMD_MIXING:
13470 {
13471 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
13472 break;
13473 }
13474
13475 case AUDIO_PCM_CMD_MIXINGGROUP:
13476 {
13477 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
13478 break;
13479 }
13480
13481 case AUDIO_PCM_CMD_BUFFER:
13482 {
13483 /*
13484 * TODO, need better coding
13485 *
13486 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
13487 */
13488 break;
13489 }
13490
13491 case AUDIO_PCM_CMD_BUFFERDURATION:
13492 {
13493 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
13494 break;
13495 }
13496
13497 case AUDIO_PCM_CMD_READPTR:
13498 {
13499 /*
13500 * TODO, need better coding
13501 *
13502 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
13503 */
13504 break;
13505 }
13506
13507 case AUDIO_PCM_CMD_WRITEPTR:
13508 {
13509 /*
13510 * TODO, need better coding
13511 *
13512 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
13513 */
13514 break;
13515 }
13516
13517 case AUDIO_PCM_CMD_CHANNEL:
13518 {
13519 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
13520 break;
13521 }
13522
13523 case AUDIO_PCM_CMD_SAMPLERATE:
13524 {
13525 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
13526 break;
13527 }
13528
13529 case AUDIO_PCM_CMD_BITWIDTH:
13530 {
13531 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
13532 break;
13533 }
13534
13535 case AUDIO_PCM_CMD_BIGENDIAN:
13536 {
13537 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
13538 break;
13539 }
13540
13541 case AUDIO_PCM_CMD_TIMESTAMP:
13542 {
13543 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
13544 break;
13545 }
13546
13547 case AUDIO_PCM_CMD_WEIGHTING:
13548 {
13549 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
13550 break;
13551 }
13552
13553 case AUDIO_PCM_CMD_VOLUME:
13554 {
13555 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
13556 break;
13557 }
13558
13559 case AUDIO_PCM_CMD_BUFFERLEVEL:
13560 {
13561 MS_U32 u32WritePtrOffset = 0;
13562 MS_U32 u32BufferSize = 0;
13563 MS_S32 s32PcmLevel = 0;
13564
13565 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13566 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
13567
13568 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
13569 if (s32PcmLevel < 0)
13570 {
13571 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13572 s32PcmLevel += u32BufferSize;
13573 }
13574
13575 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
13576 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
13577
13578 break;
13579 }
13580
13581 case AUDIO_PCM_CMD_MUTE:
13582 {
13583 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
13584 break;
13585 }
13586
13587 case AUDIO_PCM_CMD_BUFFERSIZE:
13588 {
13589 *((MS_U32 *)pData) = PCM_CAPTURE1_BUF_SIZE;
13590
13591 break;
13592 }
13593
13594 default:
13595 {
13596 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13597 break;
13598 }
13599 }
13600
13601 return s32Ret;
13602 }
13603
HAL_AUDIO_PCM_Capture1_Read(void * pBuf,MS_U32 u32Size)13604 MS_U32 HAL_AUDIO_PCM_Capture1_Read(void *pBuf, MS_U32 u32Size)
13605 {
13606 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13607 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13608 MS_S8 *pBufTmp = NULL;
13609 MS_U32 u32BufferSize = 0;
13610 MS_U32 u32PcmLevel = 0;
13611 MS_U32 u32RequestSize = 0;
13612 MS_U32 u32RequestSizeTmp = 0;
13613 MS_U32 u32SizeToCopy = 0;
13614 MS_U32 u32RptrOffset = 0;
13615 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
13616
13617 if (pBuf == NULL)
13618 {
13619 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
13620 return 0;
13621 }
13622
13623 if (u32Size == 0)
13624 {
13625 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
13626 return 0;
13627 }
13628
13629 if (pPcmInfo->u8ConnectFlag == FALSE)
13630 {
13631 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13632 return 0;
13633 }
13634
13635 if (pPcmInfo->u8StartFlag == FALSE)
13636 {
13637 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
13638 return 0;
13639 }
13640
13641 pBufTmp = (MS_S8 *)pBuf;
13642
13643 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13644 HAL_AUDIO_PCM_Capture1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
13645 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE1_BUF_UNIT))
13646 {
13647 HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
13648
13649 u32PcmLevel = 0;
13650 HAL_AUDIO_PCM_Capture1_Stop();
13651 HAL_AUDIO_PCM_Capture1_Restart();
13652 HAL_AUDIO_PCM_Capture1_Start();
13653 }
13654
13655 u32RequestSize = u32Size;
13656 u32RequestSizeTmp = u32RequestSize;
13657
13658 /* copy data from PCM buffer */
13659 if (u32PcmLevel >= u32RequestSize)
13660 {
13661 do {
13662 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
13663 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
13664
13665 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
13666
13667 pBufTmp += u32SizeToCopy;
13668 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
13669 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13670 {
13671 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13672 {
13673 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
13674 }
13675 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13676 }
13677
13678 u32RequestSizeTmp -= u32SizeToCopy;
13679 } while (u32RequestSizeTmp > 0);
13680
13681 /* flush MIU */
13682 MsOS_FlushMemory();
13683
13684 /* update read pointer to engine */
13685 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
13686 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
13687
13688 return u32Size;
13689 }
13690
13691 //HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
13692
13693 return 0;
13694 }
13695
HAL_AUDIO_PCM_Capture1_Flush(void)13696 MS_S32 HAL_AUDIO_PCM_Capture1_Flush(void)
13697 {
13698 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
13699 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13700 MS_S32 s32Ret = 0;
13701 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13702
13703 if (pPcmInfo->u8StartFlag == FALSE)
13704 {
13705 HAL_AUDIO_PCM_Capture1_Restart();
13706 HAL_AUDIO_PCM_Capture1_Stop();
13707 }
13708
13709 return s32Ret;
13710 }
13711 #endif
13712
13713 #if AUDIO_PCM_CAPTURE2_SUPPORT
HAL_AUDIO_PCM_Capture2_Restart(void)13714 MS_S32 HAL_AUDIO_PCM_Capture2_Restart(void)
13715 {
13716 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13717 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13718 MS_U32 u32WritePtrOffset = 0;
13719 MS_U32 u32TimeoutCounter = 0;
13720 MS_S32 s32Ret = 0;
13721
13722 if (pPcmInfo->u8ConnectFlag == FALSE)
13723 {
13724 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13725 return -A_EPERM;
13726 }
13727
13728 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0x0000);
13729
13730 do {
13731 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
13732
13733 if (u32WritePtrOffset != 0)
13734 {
13735 #ifdef MSOS_TYPE_LINUX_KERNEL
13736 udelay(50);
13737 #else
13738 AUDIO_DELAY1US(50);
13739 #endif
13740 u32TimeoutCounter++;
13741 }
13742 else
13743 {
13744 break;
13745 }
13746 } while (u32TimeoutCounter < 10000);
13747
13748 /* clear PCM buffer */
13749 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE2_BUF_SIZE);
13750
13751 /* flush MIU */
13752 MsOS_FlushMemory();
13753
13754 /* reset PCM capture1 read & write pointer */
13755 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13756 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13757 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0x0000);
13758
13759 return s32Ret;
13760 }
13761
HAL_AUDIO_PCM_Capture2_Open(void * pData)13762 MS_S32 HAL_AUDIO_PCM_Capture2_Open(void *pData)
13763 {
13764 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13765 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13766 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13767 MS_U32 u32TargetBufferAddrPa = 0;
13768 MS_S32 s32Ret = 0;
13769 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13770
13771 if (pData == NULL)
13772 {
13773 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
13774 return -A_EFAULT;
13775 }
13776
13777 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13778
13779 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13780 {
13781 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13782 return -A_EINVAL;
13783 }
13784
13785 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13786 {
13787 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
13788 return -A_EINVAL;
13789 }
13790
13791 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13792 {
13793 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13794 return -A_EINVAL;
13795 }
13796
13797 if (pUserPcmInfo->u8MixingFlag == TRUE)
13798 {
13799 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
13800 return -A_EINVAL;
13801 }
13802
13803 if (pUserPcmInfo->u8CaptureFlag != TRUE)
13804 {
13805 HALAUDIO_ERROR("%s: Error! Not support playback mode!\n", __FUNCTION__);
13806 return -A_EINVAL;
13807 }
13808
13809 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)
13810 {
13811 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13812 return -A_EINVAL;
13813 }
13814
13815 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)
13816 {
13817 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13818 return -A_EINVAL;
13819 }
13820
13821 /* fill in settings */
13822 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13823 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13824 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13825 pPcmInfo->u8ConnectFlag = TRUE;
13826 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13827 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
13828 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13829 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13830 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13831 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE2_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
13832 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
13833 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
13834 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13835 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13836 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13837 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13838
13839 /* init PCM buffer address */
13840 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
13841 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13842 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13843 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13844
13845 /* restart */
13846 HAL_AUDIO_PCM_Capture2_Restart();
13847
13848 return s32Ret;
13849 }
13850
HAL_AUDIO_PCM_Capture2_Close(void)13851 MS_S32 HAL_AUDIO_PCM_Capture2_Close(void)
13852 {
13853 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13854 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13855 MS_S32 s32Ret = 0;
13856 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13857
13858 if (pPcmInfo->u8ConnectFlag != FALSE)
13859 {
13860 HAL_AUDIO_PCM_Capture2_Flush();
13861 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13862 }
13863
13864 return s32Ret;
13865 }
13866
HAL_AUDIO_PCM_Capture2_Start(void)13867 MS_S32 HAL_AUDIO_PCM_Capture2_Start(void)
13868 {
13869 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13870 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13871 MS_U32 u32BufferSize = 0;
13872 MS_S32 s32Ret = 0;
13873 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13874
13875 if (pPcmInfo->u8StartFlag == FALSE)
13876 {
13877 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
13878 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
13879
13880 pPcmInfo->u8StartFlag = TRUE;
13881 }
13882
13883 return s32Ret;
13884 }
13885
HAL_AUDIO_PCM_Capture2_Stop(void)13886 MS_S32 HAL_AUDIO_PCM_Capture2_Stop(void)
13887 {
13888 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13889 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13890 MS_S32 s32Ret = 0;
13891 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13892
13893 if (pPcmInfo->u8StartFlag != FALSE)
13894 {
13895 /* TODO, there is no such control in DSP */
13896
13897 pPcmInfo->u8StartFlag = FALSE;
13898 }
13899
13900 return s32Ret;
13901 }
13902
HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd,const void * pData)13903 MS_S32 HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd, const void *pData)
13904 {
13905 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
13906 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13907 MS_S32 s32Ret = 0;
13908 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13909
13910 if (pData == NULL)
13911 {
13912 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
13913 return -A_EFAULT;
13914 }
13915
13916 if (pPcmInfo->u8ConnectFlag == FALSE)
13917 {
13918 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
13919 return -A_EPERM;
13920 }
13921
13922 switch(u32Cmd)
13923 {
13924 case AUDIO_PCM_CMD_NONBLOCKING:
13925 {
13926 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13927
13928 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13929 {
13930 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13931 s32Ret = -A_EINVAL;
13932 break;
13933 }
13934
13935 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13936
13937 break;
13938 }
13939
13940 case AUDIO_PCM_CMD_MULTICH:
13941 {
13942 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13943
13944 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13945 {
13946 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13947 s32Ret = -A_EINVAL;
13948 break;
13949 }
13950
13951 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13952 {
13953 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13954 s32Ret = -A_EINVAL;
13955 break;
13956 }
13957
13958 pPcmInfo->u8MultiChFlag = FALSE;
13959
13960 break;
13961 }
13962
13963 case AUDIO_PCM_CMD_MIXING:
13964 {
13965 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13966
13967 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13968 {
13969 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13970 s32Ret = -A_EINVAL;
13971 break;
13972 }
13973
13974 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13975 {
13976 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
13977 s32Ret = -A_EINVAL;
13978 break;
13979 }
13980
13981 pPcmInfo->u8MixingFlag = FALSE;
13982
13983 break;
13984 }
13985
13986 case AUDIO_PCM_CMD_MIXINGGROUP:
13987 {
13988 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13989
13990 pPcmInfo->u32MixingGroup = u32MixingGroup;
13991
13992 break;
13993 }
13994
13995 case AUDIO_PCM_CMD_BUFFERDURATION:
13996 {
13997 HALAUDIO_ERROR("%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
13998 s32Ret = -A_EPERM;
13999
14000 break;
14001 }
14002
14003 case AUDIO_PCM_CMD_CHANNEL:
14004 {
14005 HALAUDIO_ERROR("%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14006 s32Ret = -A_EPERM;
14007
14008 break;
14009 }
14010
14011 case AUDIO_PCM_CMD_SAMPLERATE:
14012 {
14013 HALAUDIO_ERROR("%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14014 s32Ret = -A_EPERM;
14015
14016 break;
14017 }
14018
14019 case AUDIO_PCM_CMD_BITWIDTH:
14020 {
14021 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14022
14023 pPcmInfo->u32BitWidth = u32BitWidth;
14024
14025 break;
14026 }
14027
14028 case AUDIO_PCM_CMD_BIGENDIAN:
14029 {
14030 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14031
14032 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14033 {
14034 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
14035 return -A_EINVAL;
14036 }
14037
14038 pPcmInfo->u32BigEndian = u32BigEndian;
14039
14040 break;
14041 }
14042
14043 case AUDIO_PCM_CMD_TIMESTAMP:
14044 {
14045 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14046
14047 pPcmInfo->u32Timestamp = u32Timestamp;
14048
14049 break;
14050 }
14051
14052 case AUDIO_PCM_CMD_WEIGHTING:
14053 {
14054 MS_U32 u32Weighting = *((MS_U32 *)pData);
14055
14056 if (u32Weighting > 100)
14057 {
14058 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14059 return -A_EINVAL;
14060 }
14061
14062 pPcmInfo->u32Weighting = u32Weighting;
14063
14064 break;
14065 }
14066
14067 case AUDIO_PCM_CMD_VOLUME:
14068 {
14069 MS_U32 u32Volume = *((MS_U32 *)pData);
14070
14071 if (u32Volume > 100)
14072 {
14073 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14074 return -A_EINVAL;
14075 }
14076
14077 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14078
14079 break;
14080 }
14081
14082 case AUDIO_PCM_CMD_MUTE:
14083 {
14084 MS_U32 u32Mute = *((MS_U32*)pData);
14085
14086 if (u32Mute == TRUE)
14087 {
14088 pPcmInfo->u32Volume |= 0x80000000;
14089 }
14090 else if (u32Mute == FALSE)
14091 {
14092 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14093 }
14094 else
14095 {
14096 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
14097 s32Ret = -A_EINVAL;
14098 }
14099 break;
14100 }
14101
14102 default:
14103 {
14104 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14105 break;
14106 }
14107 }
14108
14109 return s32Ret;
14110 }
14111
HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd,void * pData)14112 MS_S32 HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd, void *pData)
14113 {
14114 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14115 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14116 MS_S32 s32Ret = 0;
14117 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14118
14119 if (pData == NULL)
14120 {
14121 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
14122 return -A_EFAULT;
14123 }
14124
14125 if (pPcmInfo->u8ConnectFlag == FALSE)
14126 {
14127 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
14128 return -A_EPERM;
14129 }
14130
14131 switch(u32Cmd)
14132 {
14133 case AUDIO_PCM_CMD_ALL:
14134 {
14135 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14136 MS_U32 u32MinSize = 0;
14137
14138 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14139 {
14140 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14141 s32Ret = -A_EINVAL;
14142 break;
14143 }
14144 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14145 {
14146 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14147 }
14148
14149 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14150 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14151 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14152
14153 break;
14154 }
14155
14156 case AUDIO_PCM_CMD_NONBLOCKING:
14157 {
14158 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14159 break;
14160 }
14161
14162 case AUDIO_PCM_CMD_MULTICH:
14163 {
14164 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14165 break;
14166 }
14167
14168 case AUDIO_PCM_CMD_MIXING:
14169 {
14170 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14171 break;
14172 }
14173
14174 case AUDIO_PCM_CMD_MIXINGGROUP:
14175 {
14176 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14177 break;
14178 }
14179
14180 case AUDIO_PCM_CMD_BUFFER:
14181 {
14182 /*
14183 * TODO, need better coding
14184 *
14185 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14186 */
14187 break;
14188 }
14189
14190 case AUDIO_PCM_CMD_BUFFERDURATION:
14191 {
14192 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14193 break;
14194 }
14195
14196 case AUDIO_PCM_CMD_READPTR:
14197 {
14198 /*
14199 * TODO, need better coding
14200 *
14201 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14202 */
14203 break;
14204 }
14205
14206 case AUDIO_PCM_CMD_WRITEPTR:
14207 {
14208 /*
14209 * TODO, need better coding
14210 *
14211 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14212 */
14213 break;
14214 }
14215
14216 case AUDIO_PCM_CMD_CHANNEL:
14217 {
14218 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14219 break;
14220 }
14221
14222 case AUDIO_PCM_CMD_SAMPLERATE:
14223 {
14224 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14225 break;
14226 }
14227
14228 case AUDIO_PCM_CMD_BITWIDTH:
14229 {
14230 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14231 break;
14232 }
14233
14234 case AUDIO_PCM_CMD_BIGENDIAN:
14235 {
14236 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14237 break;
14238 }
14239
14240 case AUDIO_PCM_CMD_TIMESTAMP:
14241 {
14242 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14243 break;
14244 }
14245
14246 case AUDIO_PCM_CMD_WEIGHTING:
14247 {
14248 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14249 break;
14250 }
14251
14252 case AUDIO_PCM_CMD_VOLUME:
14253 {
14254 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14255 break;
14256 }
14257
14258 case AUDIO_PCM_CMD_BUFFERLEVEL:
14259 {
14260 MS_U32 u32WritePtrOffset = 0;
14261 MS_U32 u32BufferSize = 0;
14262 MS_S32 s32PcmLevel = 0;
14263
14264 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14265 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
14266
14267 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
14268 if (s32PcmLevel < 0)
14269 {
14270 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14271 s32PcmLevel += u32BufferSize;
14272 }
14273
14274 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
14275 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
14276
14277 break;
14278 }
14279
14280 case AUDIO_PCM_CMD_MUTE:
14281 {
14282 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
14283 break;
14284 }
14285
14286 case AUDIO_PCM_CMD_BUFFERSIZE:
14287 {
14288 *((MS_U32 *)pData) = PCM_CAPTURE2_BUF_SIZE;
14289
14290 break;
14291 }
14292
14293 default:
14294 {
14295 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14296 break;
14297 }
14298 }
14299
14300 return s32Ret;
14301 }
14302
HAL_AUDIO_PCM_Capture2_Read(void * pBuf,MS_U32 u32Size)14303 MS_U32 HAL_AUDIO_PCM_Capture2_Read(void *pBuf, MS_U32 u32Size)
14304 {
14305 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14306 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14307 MS_S8 *pBufTmp = NULL;
14308 MS_U32 u32BufferSize = 0;
14309 MS_U32 u32PcmLevel = 0;
14310 MS_U32 u32RequestSize = 0;
14311 MS_U32 u32RequestSizeTmp = 0;
14312 MS_U32 u32SizeToCopy = 0;
14313 MS_U32 u32RptrOffset = 0;
14314 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14315
14316 if (pBuf == NULL)
14317 {
14318 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14319 return 0;
14320 }
14321
14322 if (u32Size == 0)
14323 {
14324 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14325 return 0;
14326 }
14327
14328 if (pPcmInfo->u8ConnectFlag == FALSE)
14329 {
14330 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
14331 return 0;
14332 }
14333
14334 if (pPcmInfo->u8StartFlag == FALSE)
14335 {
14336 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
14337 return 0;
14338 }
14339
14340 pBufTmp = (MS_S8 *)pBuf;
14341
14342 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14343 HAL_AUDIO_PCM_Capture2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14344 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE2_BUF_UNIT))
14345 {
14346 HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
14347
14348 u32PcmLevel = 0;
14349 HAL_AUDIO_PCM_Capture2_Stop();
14350 HAL_AUDIO_PCM_Capture2_Restart();
14351 HAL_AUDIO_PCM_Capture2_Start();
14352 }
14353
14354 u32RequestSize = u32Size;
14355 u32RequestSizeTmp = u32RequestSize;
14356
14357 /* copy data from PCM buffer */
14358 if (u32PcmLevel >= u32RequestSize)
14359 {
14360 do {
14361 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
14362 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14363
14364 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14365
14366 pBufTmp += u32SizeToCopy;
14367 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
14368 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14369 {
14370 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14371 {
14372 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14373 }
14374 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14375 }
14376
14377 u32RequestSizeTmp -= u32SizeToCopy;
14378 } while (u32RequestSizeTmp > 0);
14379
14380 /* flush MIU */
14381 MsOS_FlushMemory();
14382
14383 /* update read pointer to engine */
14384 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
14385 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
14386
14387 return u32Size;
14388 }
14389
14390 //HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14391
14392 return 0;
14393 }
14394
HAL_AUDIO_PCM_Capture2_Flush(void)14395 MS_S32 HAL_AUDIO_PCM_Capture2_Flush(void)
14396 {
14397 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14398 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14399 MS_S32 s32Ret = 0;
14400 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14401
14402 if (pPcmInfo->u8StartFlag == FALSE)
14403 {
14404 HAL_AUDIO_PCM_Capture2_Restart();
14405 HAL_AUDIO_PCM_Capture2_Stop();
14406 }
14407
14408 return s32Ret;
14409 }
14410 #endif
14411
14412 #if AUDIO_HW_DMA_WRITER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)14413 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)
14414 {
14415 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14416 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14417 //MS_U32 u32WritePtrOffset = 0;
14418 //MS_U32 u32TimeoutCounter = 0;
14419 MS_S32 s32Ret = 0;
14420
14421 if (pPcmInfo->u8ConnectFlag == FALSE)
14422 {
14423 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
14424 return -A_EPERM;
14425 }
14426
14427 /* clear PCM buffer */
14428 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_WTR1_BUF_SIZE);
14429
14430 /* flush MIU */
14431 MsOS_FlushMemory();
14432 return s32Ret;
14433 }
14434
HAL_AUDIO_PCM_HwDma_Writer1_Open(void * pData)14435 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Open(void *pData)
14436 {
14437 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14438 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14439 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
14440 MS_U32 u32TargetBufferAddrPa = 0;
14441 MS_U32 u32TargetBufferSize = 0;
14442 MS_U32 u32TargetChannel = 0;
14443 MS_U32 u32TargetBitWidth = 0;
14444 MS_U32 u32TargetAlignmentSize = 0;
14445 MS_S32 s32Ret = 0;
14446 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
14447
14448 if (pData == NULL)
14449 {
14450 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
14451 return -A_EFAULT;
14452 }
14453
14454 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14455
14456 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14457 {
14458 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14459 return -A_EINVAL;
14460 }
14461
14462 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
14463 {
14464 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, (int)sizeof(AUDIO_PCM_INFO_t));
14465 return -A_EINVAL;
14466 }
14467
14468 if (pUserPcmInfo->u8MultiChFlag == TRUE)
14469 {
14470 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14471 return -A_EINVAL;
14472 }
14473
14474 if (pUserPcmInfo->u8MixingFlag == TRUE)
14475 {
14476 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
14477 return -A_EINVAL;
14478 }
14479
14480 if (pUserPcmInfo->u8CaptureFlag != TRUE)
14481 {
14482 HALAUDIO_ERROR("%s: Error! Not support playback mode!\n", __FUNCTION__);
14483 return -A_EINVAL;
14484 }
14485
14486 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)
14487 {
14488 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
14489 return -A_EINVAL;
14490 }
14491
14492 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)
14493 {
14494 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
14495 return -A_EINVAL;
14496 }
14497
14498 /* fill in settings */
14499 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14500 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
14501 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
14502 pPcmInfo->u8ConnectFlag = TRUE;
14503 strncpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14504 strncpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH);
14505
14506 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
14507 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
14508 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
14509 pPcmInfo->u32BufferDuration = ((HW_DMA_WTR1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
14510 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
14511 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;;
14512 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
14513 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
14514 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
14515 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
14516
14517 /* init PCM buffer address */
14518 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR;
14519 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
14520 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14521 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14522
14523 /* set PCM buffer address */
14524 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
14525 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE) & 0xFFFF);
14526 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
14527
14528 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x80, 0x80);
14529 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x0F, M2S_MBOX_GET_Raw);
14530
14531 /* calculate buffer size */
14532 u32TargetChannel = 2;
14533 u32TargetBitWidth = 16;
14534 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
14535 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
14536 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
14537 if (u32TargetBufferSize > HW_DMA_WTR1_BUF_SIZE)
14538 {
14539 HALAUDIO_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);
14540 u32TargetBufferSize = HW_DMA_WTR1_BUF_SIZE;
14541 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
14542 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
14543 }
14544
14545 /* set buffer size */
14546 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
14547 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
14548
14549 /* Reset and Start DMA Writer */
14550 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
14551 AUDIO_DELAY1US(1);
14552 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
14553
14554 /* restart */
14555 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
14556
14557 return s32Ret;
14558 }
14559
HAL_AUDIO_PCM_HwDma_Writer1_Close(void)14560 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Close(void)
14561 {
14562 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14563 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14564 MS_S32 s32Ret = 0;
14565 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
14566
14567 if (pPcmInfo->u8ConnectFlag != FALSE)
14568 {
14569 HAL_AUDIO_PCM_HwDma_Writer1_Flush();
14570 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14571 }
14572
14573 return s32Ret;
14574 }
14575
HAL_AUDIO_PCM_HwDma_Writer1_Start(void)14576 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Start(void)
14577 {
14578 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14579 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14580 //MS_U32 u32BufferSize = 0;
14581 MS_S32 s32Ret = 0;
14582 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
14583
14584 if (pPcmInfo->u8StartFlag == FALSE)
14585 {
14586 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0001);
14587 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0002);
14588
14589 pPcmInfo->u8StartFlag = TRUE;
14590 }
14591
14592 return s32Ret;
14593 }
14594
HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)14595 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)
14596 {
14597 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14598 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14599 MS_S32 s32Ret = 0;
14600 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
14601
14602 if (pPcmInfo->u8StartFlag != FALSE)
14603 {
14604 /* TODO, there is no such control in DSP */
14605
14606 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0000);
14607 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0000);
14608
14609 pPcmInfo->u8StartFlag = FALSE;
14610 }
14611
14612 return s32Ret;
14613 }
14614
HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd,const void * pData)14615 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd, const void *pData)
14616 {
14617 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14618 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14619 MS_S32 s32Ret = 0;
14620 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14621
14622 if (pData == NULL)
14623 {
14624 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
14625 return -A_EFAULT;
14626 }
14627
14628 if (pPcmInfo->u8ConnectFlag == FALSE)
14629 {
14630 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
14631 return -A_EPERM;
14632 }
14633
14634 switch(u32Cmd)
14635 {
14636 case AUDIO_PCM_CMD_NONBLOCKING:
14637 {
14638 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
14639
14640 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
14641 {
14642 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
14643 s32Ret = -A_EINVAL;
14644 break;
14645 }
14646
14647 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
14648
14649 break;
14650 }
14651
14652 case AUDIO_PCM_CMD_MULTICH:
14653 {
14654 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
14655
14656 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
14657 {
14658 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
14659 s32Ret = -A_EINVAL;
14660 break;
14661 }
14662
14663 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
14664 {
14665 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14666 s32Ret = -A_EINVAL;
14667 break;
14668 }
14669
14670 pPcmInfo->u8MultiChFlag = FALSE;
14671
14672 break;
14673 }
14674
14675 case AUDIO_PCM_CMD_MIXING:
14676 {
14677 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
14678
14679 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
14680 {
14681 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
14682 s32Ret = -A_EINVAL;
14683 break;
14684 }
14685
14686 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
14687 {
14688 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
14689 s32Ret = -A_EINVAL;
14690 break;
14691 }
14692
14693 pPcmInfo->u8MixingFlag = FALSE;
14694
14695 break;
14696 }
14697
14698 case AUDIO_PCM_CMD_MIXINGGROUP:
14699 {
14700 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
14701
14702 pPcmInfo->u32MixingGroup = u32MixingGroup;
14703
14704 break;
14705 }
14706
14707 case AUDIO_PCM_CMD_BUFFERDURATION:
14708 {
14709 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
14710
14711 if (u32BufferDuration == 0)
14712 {
14713 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
14714 s32Ret = -A_EINVAL;
14715 break;
14716 }
14717
14718 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
14719 {
14720 pPcmInfo->u32BufferDuration = u32BufferDuration;
14721 pPCM->u8SettingChangeFlag = TRUE;
14722 }
14723
14724 break;
14725 }
14726
14727 case AUDIO_PCM_CMD_CHANNEL:
14728 {
14729 HALAUDIO_ERROR("%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14730 s32Ret = -A_EPERM;
14731
14732 break;
14733 }
14734
14735 case AUDIO_PCM_CMD_SAMPLERATE:
14736 {
14737 HALAUDIO_ERROR("%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14738 s32Ret = -A_EPERM;
14739
14740 break;
14741 }
14742
14743 case AUDIO_PCM_CMD_BITWIDTH:
14744 {
14745 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14746
14747 pPcmInfo->u32BitWidth = u32BitWidth;
14748
14749 break;
14750 }
14751
14752 case AUDIO_PCM_CMD_BIGENDIAN:
14753 {
14754 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14755
14756 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14757 {
14758 HALAUDIO_ERROR("%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
14759 return -A_EINVAL;
14760 }
14761
14762 pPcmInfo->u32BigEndian = u32BigEndian;
14763
14764 break;
14765 }
14766
14767 case AUDIO_PCM_CMD_TIMESTAMP:
14768 {
14769 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14770
14771 pPcmInfo->u32Timestamp = u32Timestamp;
14772
14773 break;
14774 }
14775
14776 case AUDIO_PCM_CMD_WEIGHTING:
14777 {
14778 MS_U32 u32Weighting = *((MS_U32 *)pData);
14779
14780 if (u32Weighting > 100)
14781 {
14782 HALAUDIO_ERROR("%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14783 return -A_EINVAL;
14784 }
14785
14786 pPcmInfo->u32Weighting = u32Weighting;
14787
14788 break;
14789 }
14790
14791 case AUDIO_PCM_CMD_VOLUME:
14792 {
14793 MS_U32 u32Volume = *((MS_U32 *)pData);
14794
14795 if (u32Volume > 100)
14796 {
14797 HALAUDIO_ERROR("%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14798 return -A_EINVAL;
14799 }
14800
14801 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14802
14803 break;
14804 }
14805
14806 case AUDIO_PCM_CMD_MUTE:
14807 {
14808 MS_U32 u32Mute = *((MS_U32*)pData);
14809
14810 if (u32Mute == TRUE)
14811 {
14812 pPcmInfo->u32Volume |= 0x80000000;
14813 }
14814 else if (u32Mute == FALSE)
14815 {
14816 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14817 }
14818 else
14819 {
14820 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
14821 s32Ret = -A_EINVAL;
14822 }
14823 break;
14824 }
14825
14826 default:
14827 {
14828 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
14829 break;
14830 }
14831 }
14832
14833 return s32Ret;
14834 }
14835
HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd,void * pData)14836 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd, void *pData)
14837 {
14838 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
14839 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14840 MS_S32 s32Ret = 0;
14841 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14842
14843 if (pData == NULL)
14844 {
14845 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
14846 return -A_EFAULT;
14847 }
14848
14849 if (pPcmInfo->u8ConnectFlag == FALSE)
14850 {
14851 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
14852 return -A_EPERM;
14853 }
14854
14855 switch(u32Cmd)
14856 {
14857 case AUDIO_PCM_CMD_ALL:
14858 {
14859 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14860 MS_U32 u32MinSize = 0;
14861
14862 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14863 {
14864 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14865 s32Ret = -A_EINVAL;
14866 break;
14867 }
14868 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14869 {
14870 HALAUDIO_ERROR("%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14871 }
14872
14873 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14874 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14875 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14876
14877 break;
14878 }
14879
14880 case AUDIO_PCM_CMD_NONBLOCKING:
14881 {
14882 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14883 break;
14884 }
14885
14886 case AUDIO_PCM_CMD_MULTICH:
14887 {
14888 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14889 break;
14890 }
14891
14892 case AUDIO_PCM_CMD_MIXING:
14893 {
14894 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14895 break;
14896 }
14897
14898 case AUDIO_PCM_CMD_MIXINGGROUP:
14899 {
14900 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14901 break;
14902 }
14903
14904 case AUDIO_PCM_CMD_BUFFER:
14905 {
14906 /*
14907 * TODO, need better coding
14908 *
14909 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14910 */
14911 break;
14912 }
14913
14914 case AUDIO_PCM_CMD_BUFFERDURATION:
14915 {
14916 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14917 break;
14918 }
14919
14920 case AUDIO_PCM_CMD_READPTR:
14921 {
14922 /*
14923 * TODO, need better coding
14924 *
14925 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14926 */
14927 break;
14928 }
14929
14930 case AUDIO_PCM_CMD_WRITEPTR:
14931 {
14932 /*
14933 * TODO, need better coding
14934 *
14935 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14936 */
14937 break;
14938 }
14939
14940 case AUDIO_PCM_CMD_CHANNEL:
14941 {
14942 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14943 break;
14944 }
14945
14946 case AUDIO_PCM_CMD_SAMPLERATE:
14947 {
14948 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14949 break;
14950 }
14951
14952 case AUDIO_PCM_CMD_BITWIDTH:
14953 {
14954 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14955 break;
14956 }
14957
14958 case AUDIO_PCM_CMD_BIGENDIAN:
14959 {
14960 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14961 break;
14962 }
14963
14964 case AUDIO_PCM_CMD_TIMESTAMP:
14965 {
14966 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14967 break;
14968 }
14969
14970 case AUDIO_PCM_CMD_WEIGHTING:
14971 {
14972 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14973 break;
14974 }
14975
14976 case AUDIO_PCM_CMD_VOLUME:
14977 {
14978 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14979 break;
14980 }
14981
14982 case AUDIO_PCM_CMD_BUFFERLEVEL:
14983 {
14984 MS_U32 u32BufferLevel1 = 0;
14985 MS_U32 u32BufferLevel2 = 0;
14986 MS_U32 u32Timeout = 20;
14987
14988 while (u32Timeout > 0)
14989 {
14990 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
14991 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
14992
14993 if (u32BufferLevel1 == u32BufferLevel2)
14994 {
14995 break;
14996 }
14997
14998 u32Timeout--;
14999
15000 #ifdef MSOS_TYPE_LINUX_KERNEL
15001 udelay(1);
15002 #else
15003 AUDIO_DELAY1US(1);
15004 #endif
15005 }
15006
15007 if (u32BufferLevel1 != u32BufferLevel2)
15008 {
15009 HALAUDIO_ERROR("%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
15010 }
15011
15012 pPcmInfo->u32BufferLevel = u32BufferLevel2;
15013 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
15014
15015 break;
15016 }
15017
15018 case AUDIO_PCM_CMD_MUTE:
15019 {
15020 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
15021 break;
15022 }
15023
15024 case AUDIO_PCM_CMD_BUFFERSIZE:
15025 {
15026 *((MS_U32 *)pData) = HW_DMA_WTR1_BUF_SIZE;
15027
15028 break;
15029 }
15030
15031 default:
15032 {
15033 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
15034 break;
15035 }
15036 }
15037
15038 return s32Ret;
15039 }
15040
HAL_AUDIO_PCM_HwDma_Writer1_Read(void * pBuf,MS_U32 u32Size)15041 MS_U32 HAL_AUDIO_PCM_HwDma_Writer1_Read(void *pBuf, MS_U32 u32Size)
15042 {
15043 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15044 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15045 MS_S8 *pBufTmp = NULL;
15046 MS_U32 u32BufferSize = 0;
15047 MS_U32 u32PcmLevel = 0;
15048 MS_U32 u32RequestSize = 0;
15049 MS_U32 u32RequestSizeTmp = 0;
15050 MS_U32 u32SizeToCopy = 0;
15051 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
15052
15053 if (pBuf == NULL)
15054 {
15055 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
15056 return 0;
15057 }
15058
15059 if (u32Size == 0)
15060 {
15061 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
15062 return 0;
15063 }
15064
15065 if (pPcmInfo->u8ConnectFlag == FALSE)
15066 {
15067 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
15068 return 0;
15069 }
15070
15071 if (pPcmInfo->u8StartFlag == FALSE)
15072 {
15073 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
15074 return 0;
15075 }
15076
15077 pBufTmp = (MS_S8 *)pBuf;
15078
15079 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15080 HAL_AUDIO_PCM_HwDma_Writer1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
15081
15082 u32RequestSize = u32Size;
15083 u32RequestSizeTmp = u32RequestSize;
15084
15085 /* copy data from PCM buffer */
15086 if (u32PcmLevel >= u32RequestSize)
15087 {
15088 do {
15089 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
15090 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
15091
15092 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15093
15094 pBufTmp += u32SizeToCopy;
15095 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
15096 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15097 {
15098 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15099 {
15100 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
15101 }
15102 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15103 }
15104
15105 u32RequestSizeTmp -= u32SizeToCopy;
15106 } while (u32RequestSizeTmp > 0);
15107
15108 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
15109 HAL_AUR2_WriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
15110 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
15111
15112 return u32Size;
15113 }
15114 return 0;
15115 }
15116
HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)15117 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)
15118 {
15119 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15120 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15121 MS_S32 s32Ret = 0;
15122 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
15123
15124 if (pPcmInfo->u8StartFlag == FALSE)
15125 {
15126 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
15127 HAL_AUDIO_PCM_HwDma_Writer1_Stop();
15128 }
15129
15130 return s32Ret;
15131 }
15132 #endif
15133
HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)15134 AUDIO_DSP_CODE_TYPE HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)
15135 {
15136 AUDIO_DSP_CODE_TYPE dspCodeType = AU_DVB_STANDARD_INVALID;
15137
15138 switch (enDecSystem)
15139 {
15140 case MSAPI_AUD_ATV_BTSC:
15141 dspCodeType = AU_SIF_BTSC;
15142 break;
15143 case MSAPI_AUD_ATV_PAL:
15144 dspCodeType = AU_SIF_PALSUM;
15145 break;
15146 case MSAPI_AUD_DVB_MPEG:
15147 dspCodeType = AU_DVB_STANDARD_MPEG;
15148 break;
15149 case MSAPI_AUD_DVB_AC3:
15150 dspCodeType = AU_DVB_STANDARD_AC3;
15151 break;
15152 case MSAPI_AUD_DVB_AC3P:
15153 dspCodeType = AU_DVB_STANDARD_AC3P;
15154 break;
15155 case MSAPI_AUD_DVB_AAC:
15156 dspCodeType = AU_DVB_STANDARD_AAC;
15157 break;
15158 case MSAPI_AUD_DVB_MP3:
15159 dspCodeType = AU_DVB_STANDARD_MP3;
15160 break;
15161 case MSAPI_AUD_DVB_WMA:
15162 dspCodeType = AU_DVB_STANDARD_WMA;
15163 break;
15164 case MSAPI_AUD_DVB_RA8LBR:
15165 dspCodeType = AU_DVB_STANDARD_RA8LBR;
15166 break;
15167 case MSAPI_AUD_DVB_XPCM:
15168 dspCodeType = AU_DVB_STANDARD_XPCM;
15169 break;
15170 case MSAPI_AUD_DVB_DTS:
15171 dspCodeType = AU_DVB_STANDARD_DTS;
15172 break;
15173 case MSAPI_AUD_DVB_MS10_DDT:
15174 dspCodeType = AU_DVB_STANDARD_MS10_DDT;
15175 break;
15176 case MSAPI_AUD_DVB_MS10_DDC:
15177 dspCodeType = AU_DVB_STANDARD_MS10_DDC;
15178 break;
15179 case MSAPI_AUD_DVB_WMA_PRO:
15180 dspCodeType = AU_DVB_STANDARD_WMA_PRO;
15181 break;
15182 case MSAPI_AUD_DVB_FLAC:
15183 dspCodeType = AU_DVB_STANDARD_FLAC;
15184 break;
15185 case MSAPI_AUD_DVB_VORBIS:
15186 dspCodeType = AU_DVB_STANDARD_VORBIS;
15187 break;
15188 case MSAPI_AUD_DVB_DTSLBR:
15189 dspCodeType = AU_DVB_STANDARD_DTSLBR;
15190 break;
15191 case MSAPI_AUD_DVB_DRA:
15192 dspCodeType = AU_DVB_STANDARD_DRA;
15193 break;
15194 default:
15195 break;
15196 }
15197
15198 return dspCodeType;
15199 }