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 <asm/io.h>
102 #else
103 #include <string.h>
104 #endif
105 #include "MsCommon.h"
106 #include "MsIRQ.h"
107 #include "MsOS.h"
108 #include "MsTypes.h"
109 #include "drvSYS.h"
110 #include "../sys/halSYS.h"
111
112 // Internal Definition
113 #include "drvAUDIO.h"
114 #include "regCHIP.h"
115 #include "regAUDIO.h"
116 #include "halAUDIO.h"
117 #include "halMAD.h"
118 #include "halMAD2.h"
119 #include "halSIF.h"
120 #include "halSOUND.h"
121 #include "halAUR2.h"
122 #include "decR2_version.h"
123 #if ASND_R2_SUPPORT
124 #include "sndR2_version.h"
125 #endif
126 #include "../audsp/halAUDSP.h"
127
128 #if defined(MSOS_TYPE_NUTTX)
129 extern int lib_lowprintf(const char *format, ...);
130 #define DBG_PREFIX lib_lowprintf
131 #else
132 #define DBG_PREFIX printf
133 #endif
134
135 #if (defined ANDROID)
136 #include <sys/mman.h>
137 #include <cutils/ashmem.h>
138 #include <cutils/log.h>
139
140 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
141 #define LOGI ALOGI
142 #endif
143
144 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
145 #define LOGE ALOGE
146 #endif
147
148 #define HALAUDIO_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
149 #define HALAUDIO_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
150 #else
151 #ifdef CONFIG_MBOOT
152 #define HALAUDIO_PRINT(fmt, args...)
153 #define HALAUDIO_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
154 #else
155 #define HALAUDIO_PRINT(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
156 #define HALAUDIO_ERROR(fmt, args...) DBG_PREFIX("[[utopia]] " fmt, ## args)
157 #endif
158 #endif
159
160
161 //-------------------------------------------------------------------------------------------------
162 // Driver Compiler Options
163 //-------------------------------------------------------------------------------------------------
164 #define DBG_AUDIO(args...) //DBG_PREFIX(args)
165 #define DBG_AUDIO_LOAD(args...) //DBG_PREFIX(args)
166 #define DBG_AUDIO_ERROR(args...) //DBG_PREFIX(args)
167
168 #define AUD_ERRMSG(args...) DBG_PREFIX(args)
169 #define AUD_DBGMSG(args...) DBG_PREFIX(args)
170
171 #define HALAUDIO_CHECK_SHM_INIT \
172 do { \
173 if (g_AudioVars2 == NULL) \
174 { \
175 HALAUDIO_ERROR("%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
176 HALAUDIO_ERROR("%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
177 if (HAL_AUDIO_InitialVars() == FALSE) \
178 { \
179 MS_ASSERT(0); \
180 } \
181 } \
182 } while(0)
183
184 #ifndef MSOS_TYPE_NOS
185 void* MDrv_MPool_PA2KSEG1(void* pAddrPhys);
186 #endif
187
188 //-------------------------------------------------------------------------------------------------
189 // Local Defines
190 //-------------------------------------------------------------------------------------------------
191 #define AUDIO_HAL_ERR(x, args...) //{printf(x, ##args);}
192 #define HINIBBLE(u8Data) ((u8Data) >> 4)
193 #define LONIBBLE(u8Data) ((u8Data) << 4)
194
195 //HW DMA Reader1 configuration
196 #define HW_DMA_RDR1_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
197 #define HW_DMA_RDR1_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
198
199 //HW DMA Reader2 configuration
200 #define HW_DMA_RDR2_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
201 #define HW_DMA_RDR2_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
202
203 //SW DMA reader1 configuration
204 #define SW_DMA_RDR1_BUF_ADDR (DSP2_SW_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
205 #define SW_DMA_RDR1_BUF_SIZE ((DSP2_SW_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
206
207 //PCM Capture1 configuration
208 #define PCM_CAPTURE1_BUF_UNIT 128
209 #define PCM_CAPTURE1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
210 #define PCM_CAPTURE1_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
211
212 //PCM Capture2 configuration
213 #define PCM_CAPTURE2_BUF_UNIT 128
214 #define PCM_CAPTURE2_BUF_ADDR (DSP2_PCM_CAPTURE2_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
215 #define PCM_CAPTURE2_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
216
217 //HW DMA Writer1 configuration
218 #define HW_DMA_WTR1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
219 #define HW_DMA_WTR1_BUF_SIZE ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE) * BYTES_IN_MIU_LINE)
220
221 #ifndef UNUSED
222 #define UNUSED(x) ((x)=(x))
223 #endif
224
225 #define StereoAACOutputPCM 0
226
227 //-------------------------------------------------------------------------------------------------
228 // Local Structures
229 //-------------------------------------------------------------------------------------------------
230
231 //-------------------------------------------------------------------------------------------------
232 // Global Variables
233 //-------------------------------------------------------------------------------------------------
234 AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
235 AUDIO_INPUT_TYPE g_audioSrcType = AUDIO_DSP1_DVB_INPUT;
236 AUDIO_INPUT_TYPE g_audioSubSrcType = AUDIO_DSP1_DVB_INPUT;
237 MS_U16 g_BalanceMask = 0x0000;
238 MS_BOOL g_bAudio_loadcode_from_dram = 0, g_bIsDTV;
239 MS_VIRT _gMIO_MapBase;
240 MS_U32 g_u32bDTSCD = 0x00;
241 MS_S32 _s32AUDIOMutex = -1;
242 MS_S32 _s32AUDIOMutexReboot = -1;
243 MS_S32 _s32MutexLoadCode = -1;
244 MS_S32 _s32AUDIOMutexIDMA = -1;
245 extern AUDIO_SHARED_VARS2 * g_AudioVars2;
246
247 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
248 #else
249 AUDIO_SHARED_VARS2 g_audioShared;
250 #endif
251
252 #ifndef MSOS_TYPE_NUTTX
253 static MS_BOOL g_bAudioTeeInfoShmInitFlag = FALSE;
254 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
255 #else
256 AUDIO_TEE_INFO_SHARE_MEM gAudioTeeInfoShm;
257 #endif
258 AUDIO_TEE_INFO_SHARE_MEM *pAudioTeeInfoShm = NULL;
259
260 MS_BOOL g_bAudioTeeEnabled = FALSE, g_bAudioTeeMbxInitialized = FALSE;
261 MS_BOOL g_bDecDspSecureTeeAccessed = FALSE, g_bSndDspSecureTeeAccessed = FALSE;
262 #endif
263
264 //-------------------------------------------------------------------------------------------------
265 // Local Variables
266 //-------------------------------------------------------------------------------------------------
267 static MS_U32 curr_OS_Time=0;
268 static MS_S64 curr_PTS = 0;
269 static MS_BOOL g_bInitShmFlag = FALSE;
270 static MS_BOOL g_bEncodeDoneFlag = 0;
271 // for HW DMA Reader
272 static MS_U8 * dmaReader_writePtr;
273 static MS_U8 * dmaReader_bufStartAddress;
274 static MS_U8 * dmaReader_bufEndAddress;
275 // for HW DMA Writer
276 static MS_U8 * dmaWriter_readPtr;
277 static MS_U8 * dmaWriter_bufStartAddress;
278 static MS_U8 * dmaWriter_bufEndAddress;
279
280 static MS_U8 Dvb2DecCmd_tmp;
281
282 static AUDIO_DEC_ID DTVDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_ID3 , AU_DEC_INVALID};
283 static AUDIO_DEC_ID HDMIDecPriority[AU_DEC_MAX] = {AU_DEC_ID3, AU_DEC_ID1 , AU_DEC_INVALID};
284 static AUDIO_DEC_ID MMDecPriority[AU_DEC_MAX] = {AU_DEC_ID3, AU_DEC_ID1 , AU_DEC_INVALID};
285 static AUDIO_DEC_ID VDDecPriority[AU_DEC_MAX] = {AU_DEC_ID1, AU_DEC_INVALID , AU_DEC_INVALID};
286
287 #ifdef MSOS_TYPE_NUTTX
288 static MS_S32 _s32MadEventId = -1;
289 static MS_S32 _s32MadTaskId = -1;
290 static MBX_Msg TeeToReeMbxAckMsg;
291 static MBX_Msg msg;
292 static void _MAD_Proc(void);
293 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue);
294 #endif
295
296 MS_PHY g_pcm_capture_base_addr = 0;
297 MS_PHY g_pcm_capture2_base_addr = 0;
298
299 MS_U8 g_DSPMadMIUBank[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
300 MS_PHY g_DSPBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
301 MS_PHY g_DSPMadBaseBufferAdr[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
302 MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
303 extern MS_PHY (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
304
305 extern MS_U32 g_AudioDumpInfoCtrl;
306 extern MS_BOOL bIsNonPCMInDec2;
307 extern MS_U32 EncFrameIdx;
308 extern MS_U32 EncBuf_W_idx;
309 extern MS_U8 EncBuf_Count;
310 extern AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
311
312 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
313 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
314 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
315
316 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
317
318
319 const MS_U32 u32PathArray[8]={0x2C64, 0x2C66, 0x2C68, 0x2C6A, 0x2C65, 0x2C67, 0x2C69, 0x2C6B};
320
321 //Refine power on sequence for earphone & DAC pop noise issue
322 const AUDIO_REG_TYPE AudioPreInitTbl_Clock[] =
323 {
324
325 //-----------------Unsorted-----------------------------//Item TMP Add: setting for MPLL
326 // {0x0C00, 0xFF, 0x10},
327 // {0x0C01, 0xFF, 0x10},
328
329 //----------------AUPLL control-------------------------//Item 23
330 {0x112C9E, 0xFF, 0x20},
331 {0x112C9F, 0xFF, 0x1C},
332 {0x112C9C, 0xFF, 0x00},
333 {0x112C9D, 0xFF, 0xC0},
334 {0x112CA0, 0xFF, 0x20},
335 {0x112CA1, 0xFF, 0x1C},
336 {0x112C9C, 0xFF, 0x00},
337 {0x112C9D, 0xFF, 0x80},
338 {0x112CA2, 0x08, 0x08},// Enable reference clock
339 {0x112CA2, 0x10, 0x10},// Select 1st-order or 2nd-order synthesizer
340 {0x112C70, 0xFF, 0xB4},
341 {0x112C71, 0xFF, 0x12},
342 {0x112C72, 0xFF, 0x40},
343 {0x112C73, 0xFF, 0x04},
344 {0x112C74, 0xFF, 0x10},
345 {0x112C75, 0xFF, 0x00},
346 {0x112C76, 0xFF, 0x00},
347 {0x112C77, 0xFF, 0x03},
348 {0x112C5C, 0xFF, 0x08},
349 {0x112C5D, 0xFF, 0x00},
350
351
352 //----------------AUR2 PLL (MPLL)------------------------//Item 22
353 {0x160342, 0xFF, 0x01},
354 {0x160343, 0xFF, 0x00},
355
356 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
357
358 //---------------- Enable CLK----------------------------//Item 32
359 // DFS for DSP.
360 {0x163C61, 0x10, 0x00},
361 {0x163C61, 0x03, 0x00},
362 {0x163C60, 0x40, 0x40},
363 {0x163C60, 0x1F, 0x1F},
364 {0x163C61, 0x08, 0x08},
365 {0x163C60, 0x80, 0x00},
366 {0x163C60, 0x80, 0x80},
367 {0x163C60, 0x80, 0x00},
368
369 // DFS for R2.
370 {0x163C63, 0x03, 0x00},
371 {0x163C63, 0x10, 0x00},
372 {0x163C62, 0x40, 0x40},
373 {0x163C62, 0x1F, 0x1F},
374 {0x163C63, 0x08, 0x08},
375 {0x163C62, 0x80, 0x00},
376 {0x163C62, 0x80, 0x80},
377 {0x163C62, 0x80, 0x00},
378
379 {0x112CA4, 0xFF, 0xFF},
380 {0x112CA5, 0xFF, 0x1F},
381 {0x112CB3, 0x60, 0x60}, // Enable DEC_R2 Clock
382 {0x112CB2, 0x80, 0x80}, // Enable SND_R2 Clock
383 {0x112CB2, 0x10, 0x10}, // Enable Parser clock
384 {0x112CCB, 0x3C, 0x3C}, // Enable DSP clock
385 {0x112CAC, 0x20, 0x20}, // Only HDMI_128FS inverse in Manhattan
386
387 {0x112CAC, 0x02, 0x02}, // hdmi rx ecn for monet and manhattan only
388
389 //-----------------AudioBand----------------------------//Item 21
390 {0x112B58, 0xFF, 0xFF}, // DWA fix value
391 {0x112B59, 0xFF, 0x01},
392 {0x112B55, 0xF0, 0xF0}, // DWA fix enable
393
394 {0x112B46, 0xFF, 0x00}, // Enable Group C
395 {0x112B47, 0xFF, 0xFF},
396 {0x112B56, 0x30, 0x30}, // Enable ADC1/2
397 {0x112B57, 0xFF, 0x00},
398 {0x112C6E, 0x88, 0x88}, // Enable Grp A/B
399 {0x112B50, 0xFF, 0x00}, // DC offset value
400 {0x112B60, 0xFF, 0xC0},
401 {0x112B61, 0xFF, 0x38},
402 {0x112B62, 0xFF, 0x38},
403 {0x112B63, 0xFF, 0x38},
404
405 {0x112B40, 0xFF, 0x4E}, // Init CODEC SRC
406 {0x112B41, 0xFF, 0x00},
407
408 {0x112B54, 0xFF, 0x00},// DITHER select 0.5LSB
409 {0x112B55, 0xFF, 0x01},
410 {0x112B52, 0xFF, 0x00},// DC offset DISABLE, Dither DISABLE
411 {0x112B53, 0xFF, 0x00},
412 {0x112B55, 0x08, 0x08},// SDM FIX EN
413 {0x112B40, 0xFF, 0x0C},// Init CODEC SRC
414 {0x112B41, 0xFF, 0x00},
415 // {0x112B54, 0x04, 0x04},// DWA shift disable
416 {0x112B54, 0x01, 0x01},// SDM EN
417
418 //-----------------SDM RESET----------------------------//Item 33
419 {0x112C00, 0xF0, 0x00},
420 {0x112C00, 0xF0, 0xF0},
421 {0x112C00, 0xF0, 0x00},
422
423 //-----------------De-POP_1-----------------------------//Item 25
424 {0x112CDC, 0xF0, 0xF0},
425 {0x112CDD, 0x3F, 0x3F},
426 {0x112CDE, 0xFF, 0x00},
427 {0x112CDF, 0xFF, 0x00},
428 {0x112CE6, 0xFF, 0x01},
429 {0x112CE7, 0xFF, 0x00},
430 {0x112CE8, 0xFF, 0x00},
431 {0x112CE9, 0xFF, 0x80},
432 {0x112CE2, 0xFF, 0x01},
433 {0x112CE3, 0xFF, 0x00},
434 {0x112CE0, 0xFF, 0x30},
435 {0x112CE1, 0xFF, 0x10},
436 {0x112CEA, 0xFF, 0x08},
437 {0x112CEB, 0xFF, 0x00},
438 {0x112CEE, 0xFF, 0x00},
439 {0x112CEF, 0xFF, 0x00},
440 {0x112CEC, 0xFF, 0x30},
441 {0x112CED, 0xFF, 0x00},
442 {0x112CDE, 0xFF, 0x00},
443 {0x112CDF, 0xFF, 0x78},
444 {0x112CEA, 0xFF, 0x0C},
445 {0x112CEB, 0xFF, 0x00},
446 {0x112CEE, 0xFF, 0x81},
447 {0x112CEF, 0xFF, 0x10},
448 {0x112CEC, 0xFF, 0xC0},
449 {0x112CED, 0xFF, 0x00},
450 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
451 {0x112CDC, 0xFF, 0x00},
452 {0x112CDD, 0xFF, 0x00},
453 {0x112CE6, 0xFF, 0x00},
454 {0x112CE7, 0xFF, 0x00},
455 {0x112CE8, 0xFF, 0x00},
456 {0x112CE9, 0xFF, 0x00},
457 {0x112CEA, 0xFF, 0x00},
458 {0x112CEB, 0xFF, 0x00},
459 {0x163C63, 0x10, 0x00}, //Select R2 CLK from DFS
460 {0x163C61, 0x10, 0x00}, //Select DSP CLK from DFS
461
462 //-----------------MIU & DMA Setting---------------------------//Item 34
463 {0x112A44, 0xFF, 0x00}, //maddma fifo addr demeta
464 {0x112A45, 0xFF, 0x80},
465 {0x112AC4, 0xFF, 0x00}, //Sedma fifo addr demeta
466 {0x112AC5, 0xFF, 0x80},
467 {0x112A21, 0x04, 0x00}, //maddma fifo new mode
468 {0x112AA1, 0x04, 0x00}, //sedma fifo new mode
469
470 {0x163D03, 0x60, 0x20}, // DEC-R2 Use MIU0
471 {0x163D07, 0x60, 0x20}, // SND-R2 Use MIU0
472
473 {0x112F60, 0xFF, 0x15}, // dma miu_arb - disable high priority, configure block size to 8 lines
474 {0x112F61, 0xFF, 0x80},
475 {0x112F62, 0xFF, 0x08},
476 {0x112F63, 0xFF, 0x20},
477 {0x112F64, 0xFF, 0x00},
478 {0x112F65, 0xFF, 0x04},
479 {0x112F66, 0xFF, 0x00},
480 {0x112F67, 0xFF, 0x00},
481 {0x112F68, 0xFF, 0xFF},
482 {0x112F69, 0xFF, 0xFF},
483 {0x112F80, 0xFF, 0x15}, // cache miu_arb - disable high priority, configure block size to 8 lines
484 {0x112F81, 0xFF, 0x80},
485 {0x112F82, 0xFF, 0x08},
486 {0x112F83, 0xFF, 0x20},
487 {0x112F84, 0xFF, 0x00},
488 {0x112F85, 0xFF, 0x04},
489 {0x112F86, 0xFF, 0x00},
490 {0x112F87, 0xFF, 0x00},
491 {0x112F88, 0xFF, 0xFF},
492 {0x112F89, 0xFF, 0xFF},
493 {0x163D80, 0xFF, 0x15}, // R2 miu_arb - disable high priority, configure block size to 8 lines
494 {0x163D81, 0xFF, 0x80},
495 {0x163D82, 0xFF, 0x08},
496 {0x163D83, 0xFF, 0x20},
497 {0x163D84, 0xFF, 0x00},
498 {0x163D85, 0xFF, 0x04},
499 {0x163D86, 0xFF, 0x00},
500 {0x163D87, 0xFF, 0x00},
501 {0x163D88, 0xFF, 0xFF},
502 {0x163D89, 0xFF, 0xFF},
503 {0x163DA0, 0xFF, 0x15}, // R2_1 miu_arb - disable high priority, configure block size to 8 lines
504 {0x163DA1, 0xFF, 0x80},
505 {0x163DA2, 0xFF, 0x08},
506 {0x163DA3, 0xFF, 0x20},
507 {0x163DA4, 0xFF, 0x00},
508 {0x163DA5, 0xFF, 0x04},
509 {0x163DA6, 0xFF, 0x00},
510 {0x163DA7, 0xFF, 0x00},
511 {0x163DA8, 0xFF, 0xFF},
512 {0x163DA9, 0xFF, 0xFF},
513 {0x163E20, 0xFF, 0x15}, // dma_l2 miu_arb - disable high priority, configure block size to 8 lines
514 {0x163E21, 0xFF, 0x80},
515 {0x163E22, 0xFF, 0x08},
516 {0x163E23, 0xFF, 0x20},
517 {0x163E24, 0xFF, 0x00},
518 {0x163E25, 0xFF, 0x04},
519 {0x163E26, 0xFF, 0x00},
520 {0x163E27, 0xFF, 0x00},
521 {0x163E28, 0xFF, 0xFF},
522 {0x163E29, 0xFF, 0xFF},
523
524 {0x112940, 0x20, 0x00}, // enable R2 write buffer burst mode
525 {0x1129D7, 0x02, 0x02}, // enable R2 dynamic clock gating
526 {0x163D40, 0x20, 0x00}, // enable R2_1 write buffer burst mode
527 {0x1630D7, 0x02, 0x02}, // enable R2_1 dynamic clock gating
528 {0x112AA2, 0x40, 0x40}, // w_IRQ2n select SPDIF_TX
529 {0x112AA2, 0x10, 0x00}, // w_IRQL1n select SPDIF2 or HDMI_TX
530 {0x112BE1, 0x01, 0x01}, // w_IRQL1n select SPDIF2
531 {0x112BE2, 0x20, 0x20}, // w_IRQL1n select SPDIF2
532 {0x112BE2, 0x40, 0x40}, // w_IRQL1n select SPDIF2
533 {0x112BE2, 0x10, 0x10}, // w_IRQL1n select SPDIF2
534
535 #ifdef CONFIG_MBOOT
536 {0xFFFFFF, 0x01, 0x30}, // For Mboot power on sequence
537 #else
538 {0xFFFFFF, 0x01, 0x32}, // Fix preinit audio coming about pop noise to delay 50ms when the STR power on.
539 #endif
540
541 {0xFFFFFF, 0x00, 0x00}, // end of table
542 };
543
544 const AUDIO_REG_TYPE AudioInitTbl_0[]=
545 {
546 //-----------------De-POP_2-----------------------------//Item 26
547 {0x112CE2, 0xFF, 0x01},
548 {0x112CE3, 0xFF, 0x10},
549 {0x112CE0, 0xFF, 0x00},
550 {0x112CE1, 0xFF, 0x00},
551 {0x112CEE, 0xFF, 0x01},
552 {0x112CEF, 0xFF, 0x10},
553 {0x112CEC, 0xFF, 0xC0},
554 {0x112CED, 0xFF, 0x08},
555 {0xFFFFFF, 0x01, 0x05},// delay 5m sec
556 {0x112CEE, 0xFF, 0x01},
557 {0x112CEF, 0xFF, 0x13},
558 {0xFFFFFF, 0x01, 0x03},// delay 3m sec
559 {0x112CEE, 0xFF, 0x03},
560 {0x112CEF, 0xFF, 0x13},
561 {0x112C54, 0xFF, 0x01},
562 {0x112C55, 0xFF, 0x01},
563 {0x112CDF, 0x04, 0x04}, // EN_DAC_DISCH=0 ? EN_DAC_DISCH=1
564
565 //----------------Audio Reset---------------------------//Item 24
566 {0x112C00, 0xFF, 0x0D},
567 {0x112C01, 0xFF, 0x7F},
568 {0x112C00, 0xFF, 0x0F},// CLKGEN_RESET
569 {0x112C01, 0xFF, 0x7F},
570 {0x112C00, 0xFF, 0x0D},
571 {0x112C01, 0xFF, 0x7F},
572 {0x112C00, 0xFF, 0x00},
573 {0x112C01, 0xFF, 0x00},
574
575 //-----------------Synthesizer--------------------------//Item 29
576 {0x112BCF, 0x01, 0x00}, // DVB1 N.F.
577 {0x112BCE, 0x01, 0x01},
578 {0x112BA8, 0xFF, 0x94}, // N.f[30:16]
579 {0x112BA9, 0xFF, 0x11},
580 {0x112BAA, 0xFF, 0x00},
581 {0x112BAB, 0xFF, 0x00}, // N.f[15:0]
582 {0x112C60, 0x80, 0x80},
583 {0x112BCE, 0x01, 0x00},
584
585 {0x112BCF, 0x02, 0x02}, // DVB2 N.F.
586 {0x112BCE, 0x02, 0x02},
587 {0x112BAC, 0xFF, 0x94}, // N.f[30:16]
588 {0x112BAD, 0xFF, 0x11},
589 {0x112BAE, 0xFF, 0x00}, // N.f[15:0]
590 {0x112BAF, 0xFF, 0x00},
591 {0x112C62, 0x80, 0x80},
592 {0x112BCE, 0x02, 0x00},
593
594 {0x112BCF, 0x04, 0x04}, // DVB3 N.F.
595 {0x112BCE, 0x04, 0x04},
596 {0x112BB0, 0xFF, 0x94}, // N.f[30:16]
597 {0x112BB1, 0xFF, 0x11},
598 {0x112BB2, 0xFF, 0x00}, // N.f[15:0]
599 {0x112BB3, 0xFF, 0x00},
600 {0x112C61, 0x80, 0x80},
601 {0x112BCE, 0x04, 0x00},
602
603 {0x112BCF, 0x08, 0x08}, // DVB4 N.F.
604 {0x112BCE, 0x08, 0x08},
605 {0x112BB4, 0xFF, 0x94}, // N.f[30:16]
606 {0x112BB5, 0xFF, 0x11},
607 {0x112BB6, 0xFF, 0x00}, // N.f[15:0]
608 {0x112BB7, 0xFF, 0x00},
609 {0x112C63, 0x80, 0x80},
610 {0x112BCE, 0x08, 0x00},
611
612 {0x112C25, 0x20, 0x20},// DVB5 N.F.
613 {0x112C25, 0x10, 0x10},
614 {0x112C26, 0xFF, 0x94}, // N.f[30:16]
615 {0x112C27, 0xFF, 0x11},
616 {0x112C28, 0xFF, 0x00}, // N.f[15:0]
617 {0x112C29, 0xFF, 0x00},
618 {0x112C25, 0x80, 0x80},
619 {0x112C25, 0x10, 0x00},
620
621 {0x112C25, 0x02, 0x02},// DVB6 N.F.
622 {0x112C25, 0x01, 0x01},
623 {0x112C2A, 0xFF, 0x94}, // N.f[30:16]
624 {0x112C2B, 0xFF, 0x11},
625 {0x112C2C, 0xFF, 0x00}, // N.f[15:0]
626 {0x112C2D, 0xFF, 0x00},
627 {0x112C25, 0x08, 0x08},
628 {0x112C25, 0x01, 0x00},
629
630 {0x112BCF, 0x10, 0x10},// NonPCM
631 {0x112BCE, 0x20, 0x20},
632 {0x112BB8, 0xFF, 0x94}, // N.f[30:16]
633 {0x112BB9, 0xFF, 0x11},
634 {0x112BBA, 0xFF, 0x00}, // N.f[15:0]
635 {0x112BBB, 0xFF, 0x00},
636 {0x112C8B, 0x40, 0x40},
637 {0x112BCE, 0x20, 0x00},
638
639 {0x112BCF, 0x20, 0x20},// NonPCM2
640 {0x112BCE, 0x10, 0x10},
641 {0x112BD0, 0xFF, 0x94},
642 {0x112BD1, 0xFF, 0x11},
643 {0x112BD2, 0xFF, 0x00},
644 {0x112BD3, 0xFF, 0x00},
645 {0x112C5E, 0x40, 0x40},
646 {0x112BCE, 0x10, 0x00},
647
648 {0x112BCF, 0x40, 0x40},// NonPCM3
649 {0x112BCF, 0x80, 0x80},
650 {0x112BD6, 0xFF, 0x94},
651 {0x112BD7, 0xFF, 0x11},
652 {0x112BD8, 0xFF, 0x00},
653 {0x112BD9, 0xFF, 0x00},
654 {0x112C48, 0x80, 0x80},
655 {0x112BCF, 0x80, 0x00},
656
657 {0x112BCF, 0x04, 0x00}, // DVB3 N.F. is contolled by DSP
658 {0x112BCF, 0x08, 0x00}, // DVB4 N.F. is contolled by DSP
659 {0x112C25, 0x20, 0x00}, // DVB5 N.F. is contolled by DSP
660 {0x112C25, 0x02, 0x00}, // DVB6 N.F. is contolled by DSP
661
662 {0x112BCF, 0x10, 0x00}, // NonPCM1 is controlled by DSP
663 {0x112BCF, 0x20, 0x00}, // NonPCM2 is controlled by DSP
664 {0x112BCF, 0x40, 0x00}, // NonPCM3 is controlled by DSP
665
666 //-----------------Input: HDMI (only Vivaldi side)------//Item 1
667 {0x112C44, 0xFF, 0x10},// HDMI Matrix mapping
668 {0x112C45, 0xFF, 0x32},
669 {0x112C46, 0x0F, 0x00},// HDMI Matrix mapping
670 {0x112C03, 0x40, 0x40},
671 {0x112C48, 0x08, 0x08},
672 {0x112C48, 0x04, 0x00},
673 {0x112C48, 0x03, 0x00},
674 {0x112CA4, 0x08, 0x08},
675 {0x112CA4, 0x04, 0x04},
676
677 //-----------------Input: I2S---------------------------//Item 2
678 {0x112C02, 0xFF, 0x1F},// Enalbe I2S/SIF/SPDIF clock
679 {0x112C03, 0xFF, 0xC0},
680 {0x112CAE, 0xFF, 0x0E},// Enalbe I2S/SIF/SPDIF clock
681 {0x112CAF, 0xFF, 0x40},
682
683
684 //-----------------Input: SPDIF-------------------------//Item 3
685 // {0x112C0A, 0xFF, 0x90},// SPDIF_IN_CFG
686 // {0x112C0B, 0xFF, 0x53},
687 {0x112C0A, 0xFF, 0x70}, // SPDIF_IN_CFG
688 {0x112C0B, 0xFF, 0x13},
689
690 //-----------------Input: ADC---------------------------//Item 4
691 {0x112CDA, 0xFF, 0xEB},
692 {0x112CDB, 0xFF, 0x00},
693 {0x112CDA, 0xFF, 0xE8},
694 {0x112CDB, 0xFF, 0x00},
695 {0x112CF2, 0xFF, 0x21}, // ADC set dont invert
696 {0x112CF3, 0xFF, 0x00},
697 {0x112CEE, 0x20, 0x00},
698 {0x112CDB, 0x01, 0x01}, // EN_CHOP_ADC0 : decrease noise at low frequency
699 {0x112CDB, 0x02, 0x02}, // EN_CHOP_ADC0
700
701
702 //-----------------Decode Path--------------------------//Item 28
703 {0x112C60, 0xFF, 0x80},// Decoder 1 source from DVB1
704 {0x112C61, 0xFF, 0x80},// Decoder 3 source from DVB3
705 {0x112C62, 0xFF, 0x80},// Decoder 2 source from DVB2
706 {0x112C63, 0xFF, 0x87},// Decoder 4 source from SIF
707
708 //-----------------Input: Channel Source----------------//Item 6
709 {0x112C64, 0xFF, 0x80},// CH1: Source0 , CH5: ADC0
710 {0x112C65, 0xFF, 0x80},// CH5: default input source = decoder (avoid data output directly before F/W executing SourceSwitch)
711 {0x112C66, 0xFF, 0x80},// CH2: Source0 , CH6: Source1
712 {0x112C67, 0xFF, 0x81},
713 {0x112C68, 0xFF, 0x80},// CH3: Source0 , CH7: Source3
714 {0x112C69, 0xFF, 0x83},
715 {0x112C6A, 0xFF, 0x80},// CH4: Source0 , CH8: Source7
716 {0x112C6B, 0xFF, 0x87},
717
718 //-----------------Output: I2S--------------------------//Item 10
719 {0x112C90, 0x40, 0x00},
720 {0x112C90, 0x1E, 0x00},
721 {0x112C8D, 0x02, 0x00},
722 {0x112C8D, 0x01, 0x00},
723 {0x112C8C, 0x70, 0x20},
724 {0x112C8C, 0x04, 0x00},
725 {0x112C8C, 0x07, 0x02},
726 {0x112C8D, 0x80, 0x80},
727 {0x112C8D, 0x40, 0x40},
728 {0x112C8D, 0x08, 0x08},
729 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
730 {0x112C8D, 0x40, 0x00},
731 {0x112C8D, 0x08, 0x00},
732
733 //-----------------Output: SPDIF TX1--------------------//Item 11
734 {0x112C90, 0x01, 0x00},
735 {0x112C8B, 0x80, 0x80},
736 {0x112C8B, 0x20, 0x00},
737 {0x112C8B, 0x10, 0x00},
738 {0x112C8B, 0x08, 0x00},
739 {0x112C8B, 0x04, 0x00},
740 {0x112C8B, 0x02, 0x00},
741 {0x112C8B, 0x01, 0x00},
742 {0x112C8A, 0x10, 0x10}, //check channel status
743 {0x112C8A, 0x08, 0x00},
744 {0x112C8A, 0x04, 0x00},
745 {0x112C8A, 0x03, 0x00},
746 {0x112C8A, 0x80, 0x80},
747 {0x112C8A, 0x40, 0x40},
748 {0x112C8A, 0x20, 0x20},
749 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
750 {0x112C8A, 0x40, 0x00},
751 {0x112C8A, 0x20, 0x00},
752
753 //-----------------Output: DAC--------------------------//Item 12
754 {0x112CEE, 0xFF, 0x03},
755 {0x112CEF, 0xFF, 0x03},
756 {0x112CEC, 0xFF, 0x00},
757 {0x112CED, 0xFF, 0x18},
758 {0x112CF4, 0xFF, 0x00}, // compensate DAC swing
759 {0x112CF5, 0xFF, 0x10},
760
761 {0x112B52, 0xFF, 0x0F},// DC offset EN, Dither EN
762 {0x112B53, 0xFF, 0xF0},
763
764 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
765 {0x112B50, 0xFF, 0x10}, // fading DC offset 0x10 -> 0x20 -> 0x30 -> ¡K-> 0x80
766 {0x112B51, 0xFF, 0x00},
767 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
768 {0x112B50, 0xFF, 0x20},
769 {0x112B51, 0xFF, 0x00},
770 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
771 {0x112B50, 0xFF, 0x30},
772 {0x112B51, 0xFF, 0x00},
773 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
774 {0x112B50, 0xFF, 0x40},
775 {0x112B51, 0xFF, 0x00},
776 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
777 {0x112B50, 0xFF, 0x50},
778 {0x112B51, 0xFF, 0x00},
779 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
780 {0x112B50, 0xFF, 0x60},
781 {0x112B51, 0xFF, 0x00},
782 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
783 {0x112B50, 0xFF, 0x70},
784 {0x112B51, 0xFF, 0x00},
785 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
786 {0x112B50, 0xFF, 0x80},
787 {0x112B51, 0xFF, 0x00},
788
789 {0x112B55, 0x08, 0x00},// SDM FIX DISABLE
790
791 //-----------------Output: SPDIF TX2--------------------//Item 13
792
793 {0x112C5F, 0x80, 0x80},
794 {0x112C5F, 0x40, 0x40},
795 {0x112C5F, 0x20, 0x00},
796 {0x112C5F, 0x10, 0x00},
797 {0x112C5F, 0x08, 0x00},
798 {0x112C5F, 0x04, 0x00},
799 {0x112C5F, 0x02, 0x00},
800 {0x112C5F, 0x01, 0x00},
801 {0x112C5E, 0x10, 0x10}, //enable channal status
802 {0x112C5E, 0x08, 0x00},
803 {0x112C5E, 0x04, 0x00},
804 {0x112C5E, 0x03, 0x00},
805 {0x112C5E, 0x80, 0x80},
806 {0x112C5E, 0x40, 0x40},
807 {0x112C5E, 0x20, 0x20},
808 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
809 {0x112C5E, 0x40, 0x00},
810 {0x112C5E, 0x20, 0x00},
811
812
813 //-----------------Unsorted-----------------------------
814 {0x112C94, 0xFF, 0x01}, //Enable CH1/5 HW force mute
815 {0x112C95, 0xFF, 0x01},
816 {0x112C96, 0xFF, 0x01}, //Enable CH2/6 HW force mute
817 {0x112C97, 0xFF, 0x01},
818 {0x112C98, 0xFF, 0x01}, //Enable CH1/5 HW force mute
819 {0x112C99, 0xFF, 0x01},
820 {0x112C9A, 0xFF, 0x01}, //Enable CH1/5 HW force mute
821 {0x112C9B, 0xFF, 0x01},
822
823
824 // ----------------------------------------------------
825 // ADC & DACinitialize
826 //-----------------------------------------------------
827 {0x112CF2, 0x30, 0x30}, // turn off earphone internal resistor to VCM OP
828
829 {0xFFFFFF, 0x00, 0x00}, // end of table
830 };
831
832 const AUDIO_REG_TYPE AudioInitTbl_1[]=
833 {
834 // ----------------------------------------------------
835 // sound effect init settings
836 //-----------------------------------------------------
837 // if spdif change to mute, need set g_SPDIF_MuteStatus = 1;
838 {0x112C94, 0x01, 0x01}, // enable CH1 HW force mute @@VVV
839 {0x112C96, 0x01, 0x01}, // enable CH2 HW force mute @@VVV
840 {0x112C98, 0x01, 0x01}, // enable CH3 HW force mute @@VVV
841 {0x112C9A, 0x01, 0x01}, // enable CH4 HW force mute @@VVV
842 {0x112C95, 0x01, 0x01}, // enable CH5 HW force mute @@VVV
843 {0x112C97, 0x01, 0x01}, // enable CH6 HW force mute @@VVV
844 {0x112C99, 0x01, 0x01}, // enable CH7 HW force mute @@VVV
845
846 {0x112D01, 0xFF, 0x8C}, // AUOUT0 volume : 0dB ; Mute @@VVV
847 {0x112D03, 0xFF, 0x8C}, // AUOUT1 volume : 0dB ; Mute @@VVV
848 {0x112D05, 0xFF, 0x8C}, // AUOUT2 volume : 0dB ; Mute @@VVV
849 {0x112D07, 0xFF, 0x8C}, // AUOUT3 volume : 0dB ; Mute @@VVV
850 {0x112D09, 0xFF, 0x8C}, // I2S_OUT volume : 0dB ; Mute @@VVV
851 {0x112D0B, 0xFF, 0x0C}, // SPDIF_OUT volume : 0dB ; UnMute @@VVV
852
853 {0x112D20, 0x80, 0x00}, // Disable EQ @@VVV
854 {0x112D21, 0xFF, 0xC8}, // Enable Sound effect & tone @@VVV
855 {0x112D22, 0x3F, 0x3F}, // Enable all output Volume control @@VVV
856 {0x112D23, 0x01, 0x01}, // Enable SPDIF_OUT volume control @@VVV
857 {0x112D31, 0x02, 0x00}, // disable SE-DSP power-down command @@VVV
858
859 {0x112D50, 0xFF, 0xFF}, // DAC0/1 source default in NULL path @@VVV
860 {0x112D51, 0xFF, 0xFF}, // DAC2/3 source default in NULL path @@VVV
861 {0x112D52, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
862 {0x112D53, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
863 {0x112D54, 0xF0, 0x40}, // SRC source from PCM @@VVV
864
865 {0x112D59, 0xFF, 0x0C}, // set ch7 volume : 0dB; unmute
866 {0x112D58, 0xFF, 0x00},
867 {0x112D5D, 0xFF, 0x0C}, // set mix volume of CH5, CH6, CH8 to 0dB
868 {0x112D5C, 0xFF, 0x00},
869 {0x112D5F, 0xFF, 0x0C},
870 {0x112D5E, 0xFF, 0x00},
871 {0x112D5B, 0xFF, 0x0C},
872 {0x112D5A, 0xFF, 0x00},
873
874 // ----------------------------------------------------
875 // spdifTx1/spdifTx2/hdmi matrix setting
876 //-----------------------------------------------------
877 {0x112AA2, 0x60, 0x40}, //IRQ2L= spdifTx1
878 {0x112AA2, 0x10, 0x00}, //IRQ2L= spdifTx2
879
880 {0x112AA2, 0x40, 0x40}, //w_IRQ2n select SPDIF_TX
881 {0x112A80, 0x80, 0x00}, //idma control by mcu
882 {0x112C05, 0x01, 0x01}, // dummy reg to check audio init is done
883
884 {0xFFFFFF, 0x00, 0x00}, // end of table
885 };
886
887 const AUDIO_REG_TYPE2 ResetDMIOTbl[]=
888 {
889 //DMIO a0xx reset
890
891 {0x112A80 , 0xFFFF, 0x0040},
892 {0x112A80 , 0xFFFF, 0x0043},
893 {0x112a84 , 0xFFFF, 0xa05a},
894 {0x112a82 , 0xFFFF, 0x0000},
895 {0x112a82 , 0xFFFF, 0x0080},
896
897 {0x112A80 , 0xFFFF, 0x0053},
898 {0x112A80 , 0xFFFF, 0x0043},
899 {0x112a84 , 0xFFFF, 0xa05e},
900 {0x112a82 , 0xFFFF, 0x0000},
901 {0x112a82 , 0xFFFF, 0x0080},
902
903 {0x112a80 , 0xFFFF, 0x0053},
904 {0x112a80 , 0xFFFF, 0x0043},
905 {0x112a84 , 0xFFFF, 0xa062},
906 {0x112a82 , 0xFFFF, 0x0000},
907 {0x112a82 , 0xFFFF, 0x0080},
908
909 {0x112a80 , 0xFFFF, 0x0053},
910 {0x112a80 , 0xFFFF, 0x0043},
911 {0x112a84 , 0xFFFF, 0xa066},
912 {0x112a82 , 0xFFFF, 0x0000},
913 {0x112a82 , 0xFFFF, 0x0080},
914
915 {0x112a80 , 0xFFFF, 0x0053},
916 {0x112a80 , 0xFFFF, 0x0043},
917 {0x112a84 , 0xFFFF, 0xa06a},
918 {0x112a82 , 0xFFFF, 0x0000},
919 {0x112a82 , 0xFFFF, 0x0080},
920
921 {0x112a80 , 0xFFFF, 0x0053},
922 {0x112a80 , 0xFFFF, 0x0043},
923 {0x112a84 , 0xFFFF, 0xa06e},
924 {0x112a82 , 0xFFFF, 0x0000},
925 {0x112a82 , 0xFFFF, 0x0080},
926
927 {0x112a80 , 0xFFFF, 0x0053},
928 {0x112a80 , 0xFFFF, 0x0043},
929 {0x112a84 , 0xFFFF, 0xa072},
930 {0x112a82 , 0xFFFF, 0x0000},
931 {0x112a82 , 0xFFFF, 0x0080},
932
933 {0x112a80 , 0xFFFF, 0x0053},
934 {0x112a80 , 0xFFFF, 0x0043},
935 {0x112a84 , 0xFFFF, 0xa076},
936 {0x112a82 , 0xFFFF, 0x0000},
937 {0x112a82 , 0xFFFF, 0x0080},
938
939 {0x112a80 , 0xFFFF, 0x0053},
940 {0x112a80 , 0xFFFF, 0x0043},
941 {0x112a84 , 0xFFFF, 0xa07a},
942 {0x112a82 , 0xFFFF, 0x0000},
943 {0x112a82 , 0xFFFF, 0x0080},
944
945 {0x112a80 , 0xFFFF, 0x0053},
946 {0x112a80 , 0xFFFF, 0x0043},
947 {0x112a84 , 0xFFFF, 0xa07e},
948 {0x112a82 , 0xFFFF, 0x0000},
949 {0x112a82 , 0xFFFF, 0x0080},
950
951 {0x112a80 , 0xFFFF, 0x0053},
952 {0x112a80 , 0xFFFF, 0x0043},
953 {0x112a84 , 0xFFFF, 0xa082},
954 {0x112a82 , 0xFFFF, 0x0000},
955 {0x112a82 , 0xFFFF, 0x0080},
956
957 {0x112a80 , 0xFFFF, 0x0053},
958 {0x112a80 , 0xFFFF, 0x0043},
959 {0x112a84 , 0xFFFF, 0xa086},
960 {0x112a82 , 0xFFFF, 0x0000},
961 {0x112a82 , 0xFFFF, 0x0080},
962
963 {0x112a80 , 0xFFFF, 0x0053},
964 {0x112a80 , 0xFFFF, 0x0043},
965 {0x112a84 , 0xFFFF, 0xa08a},
966 {0x112a82 , 0xFFFF, 0x0000},
967 {0x112a82 , 0xFFFF, 0x0080},
968
969 {0x112a80 , 0xFFFF, 0x0053},
970 {0x112a80 , 0xFFFF, 0x0043},
971 {0x112a84 , 0xFFFF, 0xa0b5},
972 {0x112a82 , 0xFFFF, 0x0000},
973 {0x112a82 , 0xFFFF, 0x0080},
974
975 {0x112a80 , 0xFFFF, 0x0053},
976 {0x112a80 , 0xFFFF, 0x0043},
977 {0x112a84 , 0xFFFF, 0xa0e0},
978 {0x112a82 , 0xFFFF, 0x0000},
979 {0x112a82 , 0xFFFF, 0x0080},
980
981 {0x112a80 , 0xFFFF, 0x0053},
982 {0x112a80 , 0xFFFF, 0x0043},
983 {0x112a80 , 0xFFFF, 0x0000},
984 {0x112c00 , 0xFFFF, 0x7f0d},
985 {0x112c00 , 0xFFFF, 0x0000},
986
987 //end DMIO a0xx reset
988
989 {0xFFFFFF, 0x0000, 0x0000}, // end of table
990
991 };
992
993 const AUDIO_REG_TYPE Audio_stopDecTbl[] =
994 {
995 {0x160399 , 0xFF, 0x00}, // DEC R2(2R)
996 {0x16039b , 0xFF, 0x00},
997 {0x112e99 , 0xFF, 0x00}, // DEC R2(1R)
998 {0x112e9b , 0xFF, 0x00},
999 {0x112a2c , 0xFF, 0x00}, // DEC DSP
1000 {0x112aac , 0xFF, 0x00}, // SE DSP
1001
1002 {0xFFFFFF , 0x00, 0x00}, // end of table
1003 };
1004
1005 AUDIO_PCM_t Audio_Pcm_HwDma_Reader1 = {
1006 .u8Name = AUDIO_HW_DMA_READER1,
1007 .tPcmOps = {
1008 .open = HAL_AUDIO_Pcm_HwDma_Reader1_Init,
1009 .close = HAL_AUDIO_Pcm_HwDma_Reader1_Exit,
1010 .start = HAL_AUDIO_Pcm_HwDma_Reader1_Start,
1011 .stop = HAL_AUDIO_Pcm_HwDma_Reader1_Stop,
1012 .set = HAL_AUDIO_Pcm_HwDma_Reader1_Set,
1013 .get = HAL_AUDIO_Pcm_HwDma_Reader1_Get,
1014 .read = NULL,
1015 .write = HAL_AUDIO_Pcm_HwDma_Reader1_Write,
1016 .flush = HAL_AUDIO_Pcm_HwDma_Reader1_Flush,
1017 },
1018 .tPcmCaps = {
1019 .u8MultiChFlag = FALSE,
1020 .u8MixingFlag = FALSE,
1021 .u32Channel = {1, 2},
1022 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1023 .u32BitWidth = {16},
1024 },
1025 };
1026
1027 AUDIO_PCM_t Audio_Pcm_HwDma_Reader2 = {
1028 .u8Name = AUDIO_HW_DMA_READER2,
1029 .tPcmOps = {
1030 .open = HAL_AUDIO_Pcm_HwDma_Reader2_Init,
1031 .close = HAL_AUDIO_Pcm_HwDma_Reader2_Exit,
1032 .start = HAL_AUDIO_Pcm_HwDma_Reader2_Start,
1033 .stop = HAL_AUDIO_Pcm_HwDma_Reader2_Stop,
1034 .set = HAL_AUDIO_Pcm_HwDma_Reader2_Set,
1035 .get = HAL_AUDIO_Pcm_HwDma_Reader2_Get,
1036 .read = NULL,
1037 .write = HAL_AUDIO_Pcm_HwDma_Reader2_Write,
1038 .flush = HAL_AUDIO_Pcm_HwDma_Reader2_Flush,
1039 },
1040 .tPcmCaps = {
1041 .u8MultiChFlag = FALSE,
1042 .u8MixingFlag = FALSE,
1043 .u32Channel = {1, 2},
1044 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1045 .u32BitWidth = {16},
1046 },
1047 };
1048
1049 AUDIO_PCM_t Audio_Pcm_SwDma_Reader1 = {
1050 .u8Name = AUDIO_SW_DMA_READER1,
1051 .tPcmOps = {
1052 .open = HAL_AUDIO_Pcm_SwDma_Reader1_Init,
1053 .close = HAL_AUDIO_Pcm_SwDma_Reader1_Exit,
1054 .start = HAL_AUDIO_Pcm_SwDma_Reader1_Start,
1055 .stop = HAL_AUDIO_Pcm_SwDma_Reader1_Stop,
1056 .set = HAL_AUDIO_Pcm_SwDma_Reader1_Set,
1057 .get = HAL_AUDIO_Pcm_SwDma_Reader1_Get,
1058 .read = NULL,
1059 .write = HAL_AUDIO_Pcm_SwDma_Reader1_Write,
1060 .flush = HAL_AUDIO_Pcm_SwDma_Reader1_Flush,
1061 },
1062 .tPcmCaps = {
1063 .u8MultiChFlag = FALSE,
1064 .u8MixingFlag = FALSE,
1065 .u32Channel = {1, 2},
1066 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
1067 .u32BitWidth = {16},
1068 },
1069 };
1070
1071 AUDIO_PCM_t Audio_Pcm_Capture1 = {
1072 .u8Name = AUDIO_PCM_CAPTURE1,
1073 .tPcmOps = {
1074 .open = HAL_AUDIO_Pcm_Capture1_Init,
1075 .close = HAL_AUDIO_Pcm_Capture1_Exit,
1076 .start = HAL_AUDIO_Pcm_Capture1_Start,
1077 .stop = HAL_AUDIO_Pcm_Capture1_Stop,
1078 .set = HAL_AUDIO_Pcm_Capture1_Set,
1079 .get = HAL_AUDIO_Pcm_Capture1_Get,
1080 .read = HAL_AUDIO_Pcm_Capture1_Read,
1081 .write = NULL,
1082 .flush = HAL_AUDIO_Pcm_Capture1_Flush,
1083 },
1084 .tPcmCaps = {
1085 .u8MultiChFlag = FALSE,
1086 .u8MixingFlag = FALSE,
1087 .u32Channel = {2},
1088 .u32SampleRate = {48000},
1089 .u32BitWidth = {16},
1090 },
1091 };
1092
1093 AUDIO_PCM_t Audio_Pcm_Capture2 = {
1094 .u8Name = AUDIO_PCM_CAPTURE2,
1095 .tPcmOps = {
1096 .open = HAL_AUDIO_Pcm_Capture2_Init,
1097 .close = HAL_AUDIO_Pcm_Capture2_Exit,
1098 .start = HAL_AUDIO_Pcm_Capture2_Start,
1099 .stop = HAL_AUDIO_Pcm_Capture2_Stop,
1100 .set = HAL_AUDIO_Pcm_Capture2_Set,
1101 .get = HAL_AUDIO_Pcm_Capture2_Get,
1102 .read = HAL_AUDIO_Pcm_Capture2_Read,
1103 .write = NULL,
1104 .flush = HAL_AUDIO_Pcm_Capture2_Flush,
1105 },
1106 .tPcmCaps = {
1107 .u8MultiChFlag = FALSE,
1108 .u8MixingFlag = FALSE,
1109 .u32Channel = {2},
1110 .u32SampleRate = {48000},
1111 .u32BitWidth = {16},
1112 },
1113 };
1114
1115 AUDIO_PCM_t Audio_Pcm_HwDma_Writer1 = {
1116 .u8Name = AUDIO_HW_DMA_WRITER1,
1117 .tPcmOps = {
1118 .open = HAL_AUDIO_Pcm_HwDma_Writer1_Init,
1119 .close = HAL_AUDIO_Pcm_HwDma_Writer1_Exit,
1120 .start = HAL_AUDIO_Pcm_HwDma_Writer1_Start,
1121 .stop = HAL_AUDIO_Pcm_HwDma_Writer1_Stop,
1122 .set = HAL_AUDIO_Pcm_HwDma_Writer1_Set,
1123 .get = HAL_AUDIO_Pcm_HwDma_Writer1_Get,
1124 .read = HAL_AUDIO_Pcm_HwDma_Writer1_Read,
1125 .write = NULL,
1126 .flush = HAL_AUDIO_Pcm_HwDma_Writer1_Flush,
1127 },
1128 .tPcmCaps = {
1129 .u8MultiChFlag = FALSE,
1130 .u8MixingFlag = FALSE,
1131 .u32Channel = {2},
1132 .u32SampleRate = {48000},
1133 .u32BitWidth = {16},
1134 },
1135 };
1136
1137 AUDIO_PCM_t *g_PCM[AUDIO_PCM_MAXNUM] = {
1138 &Audio_Pcm_HwDma_Reader1,
1139 &Audio_Pcm_SwDma_Reader1,
1140 &Audio_Pcm_Capture1,
1141 &Audio_Pcm_Capture2,
1142 &Audio_Pcm_HwDma_Reader2,
1143 &Audio_Pcm_HwDma_Writer1,
1144 };
1145
1146
1147 //-------------------------------------------------------------------------------------------------
1148 // Debug Functions
1149 //-------------------------------------------------------------------------------------------------
1150
1151 //-------------------------------------------------------------------------------------------------
1152 // Local Functions
1153 //-------------------------------------------------------------------------------------------------
1154
1155 ////////////////////////////////////////////////////////////////////////////////
1156 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus()
1157 /// @brief \b Function \b Description: Return audio status.
1158 /// @return MS_U16 \b : return structure which include pcm, non pcm, sampling rate.
1159 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus(ST_HDMI_AUDIO_STATUS * p_hdmiAudioSts)1160 MS_BOOL HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus( ST_HDMI_AUDIO_STATUS *p_hdmiAudioSts)
1161 {
1162 MS_U32 smpRate;
1163 MS_BOOL ret;
1164 ret = true;
1165 if (HAL_AUDIO_HDMI_NonpcmMonitor())
1166 {
1167 switch(HAL_AUDIO_HDMI_DolbyMonitor())
1168 {
1169 case 0x01: p_hdmiAudioSts->audio_type = HDMI_RX_DD; break;
1170 case 0x0b: p_hdmiAudioSts->audio_type = HDMI_RX_DTS; break;
1171 case 0x15: p_hdmiAudioSts->audio_type = HDMI_RX_DDP; break;
1172 default: p_hdmiAudioSts->audio_type = HDMI_RX_Other; break;
1173 }
1174 }
1175 else
1176 p_hdmiAudioSts->audio_type = HDMI_RX_PCM;
1177
1178 if (_AU_AbsRead2Byte(0x101A04)&0x8000)
1179 {
1180 p_hdmiAudioSts->sampleRate = AUDIO_FS_NONE;
1181 ret = false;
1182 }
1183 else
1184 {
1185 smpRate = 216000000/_AU_AbsRead2Byte(0x101A04);
1186
1187 if (smpRate>182400) //192k*0.95
1188 {
1189 p_hdmiAudioSts->sampleRate = AUDIO_FS_192KHZ;
1190 }
1191 else if (smpRate>167200) //176k*0.95
1192 {
1193 p_hdmiAudioSts->sampleRate = AUDIO_FS_176KHZ;
1194 }
1195 else if (smpRate>91200) //92k*0.95
1196 {
1197 p_hdmiAudioSts->sampleRate = AUDIO_FS_96KHZ;
1198 }
1199 else if (smpRate>83600) //88k*0.95
1200 {
1201 p_hdmiAudioSts->sampleRate = AUDIO_FS_88KHZ;
1202 }
1203 else if (smpRate>60800) //64k*0.95
1204 {
1205 p_hdmiAudioSts->sampleRate = AUDIO_FS_64KHZ;
1206 }
1207 else if (smpRate>45600) //48k*0.95
1208 {
1209 p_hdmiAudioSts->sampleRate = AUDIO_FS_48KHZ;
1210 }
1211 else if (smpRate>41800) //44k*0.95
1212 {
1213 p_hdmiAudioSts->sampleRate = AUDIO_FS_44KHZ;
1214 }
1215 else if (smpRate>30400) //32k*0.95
1216 {
1217 p_hdmiAudioSts->sampleRate = AUDIO_FS_32KHZ;
1218 }
1219 else if (smpRate>22800) //24k*0.95
1220 {
1221 p_hdmiAudioSts->sampleRate = AUDIO_FS_24KHZ;
1222 }
1223 else if (smpRate>20900) //22k*0.95
1224 {
1225 p_hdmiAudioSts->sampleRate = AUDIO_FS_22KHZ;
1226 }
1227 else if (smpRate>15200) //16k*0.95
1228 {
1229 p_hdmiAudioSts->sampleRate = AUDIO_FS_16KHZ;
1230 }
1231 else if (smpRate>11400) //12k*0.95
1232 {
1233 p_hdmiAudioSts->sampleRate = AUDIO_FS_12KHZ;
1234 }
1235 else if (smpRate>10450) //11k*0.95
1236 {
1237 p_hdmiAudioSts->sampleRate = AUDIO_FS_11KHZ;
1238 }
1239 else if (smpRate>7600) //8k*0.95
1240 {
1241 p_hdmiAudioSts->sampleRate = AUDIO_FS_8KHZ;
1242 }
1243 else
1244 {
1245 p_hdmiAudioSts->sampleRate = AUDIO_FS_NONE;
1246 }
1247 }
1248 return ret;
1249
1250 }
1251
HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)1252 MS_BOOL HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)
1253 {
1254 MS_U8 i = 0;
1255 MS_U8 array_mount = 0;
1256
1257 if (pAUDIOShared == NULL)
1258 {
1259 return FALSE;
1260 }
1261
1262 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1263
1264 /* Fill in default value */
1265 pAUDIOShared->g_DspCodeType = AU_DVB_STANDARD_INVALID;
1266 pAUDIOShared->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
1267 pAUDIOShared->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
1268 pAUDIOShared->g_u8DspAliveFlag = TRUE;
1269 pAUDIOShared->g_eSpdifOutputType = SPDIF_OUT_NONE;
1270 pAUDIOShared->g_SpdifNpcmPath = AUDIO_DSP_ID_ALL;
1271
1272 pAUDIOShared->g_u8SifDspType = DSP_SE;
1273
1274
1275 array_mount = sizeof(pAUDIOShared->sif_gain_0) / sizeof(pAUDIOShared->sif_gain_0[0]);
1276 for (i = 0; i < array_mount; i++)
1277 {
1278 /* Note! sif_gain_0[] is expected same length as sif_shift_0[] */
1279 pAUDIOShared->sif_gain_0[i] = 0x7FFF;
1280 pAUDIOShared->sif_shift_0[i] = 0x0000;
1281 }
1282 pAUDIOShared->g_u8IntTag = 1;
1283 pAUDIOShared->int_mb_cnt = 0;
1284
1285 pAUDIOShared->CompressInfo = 0;
1286 for ( i = 0; i < MAX_AUDIO_BASE_ADDRESS_NUM2; i++ )
1287 {
1288 pAUDIOShared->g_DSPMadMIUBank[i] = g_DSPMadMIUBank[i];
1289 pAUDIOShared->g_DSPBinBaseAddress[i] = g_DSPBinBaseAddress[i];
1290 pAUDIOShared->g_DSPMadBaseBufferAdr[i] = g_DSPMadBaseBufferAdr[i];
1291 pAUDIOShared->g_DSPDDRBinBaseAddress[i] = g_DSPDDRBinBaseAddress[i];
1292 }
1293
1294 pAUDIOShared->eMainSourceType = E_AUDIO_INFO_DTV_IN;
1295 pAUDIOShared->ePrevSourceType = E_AUDIO_INFO_DTV_IN;
1296
1297 pAUDIOShared->eAudioSource = E_AUDIO_INFO_ADC_IN;
1298 pAUDIOShared->eMainAudioSource = AUDIO_NULL_INPUT;
1299 pAUDIOShared->eSubAudioSource = AUDIO_NULL_INPUT;
1300 pAUDIOShared->eScartAudioSource = AUDIO_NULL_INPUT;
1301
1302 pAUDIOShared->g_SPDIF_MuteStatus = 0;
1303
1304 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1305 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8R2NonPcmSetting = 0x00;
1306 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1307 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1308
1309 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1310 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8R2NonPcmSetting = 0x00;
1311 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1312 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1313
1314 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
1315 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8R2NonPcmSetting = 0x00;
1316 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
1317 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
1318
1319 pAUDIOShared->g_dolbyLoudness_DTVsystem = DVB_MODE;
1320 pAUDIOShared->g_dolbyLoudness_Enable = 1;
1321
1322 /* 1st decoder (depends on chip) */
1323 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsVersion = AUD_CAP_VERSION;
1324 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1325 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum = 2;
1326 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDmaReaderNum = 2;
1327 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsADSupported = TRUE;
1328 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsPusiDetectSupported = FALSE;
1329 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMpegSupported = TRUE;
1330 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3Supported = TRUE;
1331 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3pSupported = TRUE;
1332 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAacSupported = TRUE;
1333 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMp3Supported = TRUE;
1334 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaSupported = TRUE;
1335 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsRa8LbrSupported = TRUE;
1336 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsXpcmSupported = TRUE;
1337 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsSupported = TRUE;
1338 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaProSupported = TRUE;
1339 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsFlacSupported = TRUE;
1340 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsVorbisSupported = TRUE;
1341 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsLbrSupported = TRUE;
1342 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrNbSupported = TRUE;
1343 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrWbSupported = TRUE;
1344 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDraSupported = TRUE;
1345
1346 /* 2nd decoder (depends on chip) */
1347 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsVersion = AUD_CAP_VERSION;
1348 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
1349 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDecoderNum = 2;
1350 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDmaReaderNum = 2;
1351 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsADSupported = FALSE;
1352 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsPusiDetectSupported = FALSE;
1353 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMpegSupported = TRUE;
1354 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3Supported = TRUE;
1355 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3pSupported = TRUE;
1356 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAacSupported = TRUE;
1357 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMp3Supported = TRUE;
1358 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaSupported = TRUE;
1359 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsRa8LbrSupported = TRUE;
1360 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsXpcmSupported = TRUE;
1361 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsSupported = TRUE;
1362 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaProSupported = TRUE;
1363 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsFlacSupported = TRUE;
1364 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsVorbisSupported = TRUE;
1365 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsLbrSupported = TRUE;
1366 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrNbSupported = TRUE;
1367 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrWbSupported = TRUE;
1368 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDraSupported = TRUE;
1369
1370 pAUDIOShared->g_hbr_bypass_enable = FALSE;
1371
1372 return TRUE;
1373 }
1374
HAL_AUDIO_AllocateVars(void)1375 AUDIO_SHARED_VARS2 * HAL_AUDIO_AllocateVars(void)
1376 {
1377 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1378
1379 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1380 MS_U32 u32ShmId = 0;
1381 AUDIO_SHARED_VARS2 *virtAddr = 0;
1382 MS_U32 u32BufSize = 0;
1383
1384 HALAUDIO_ERROR("Start %s InitShmFlag=%d\r\n", __FUNCTION__, g_bInitShmFlag);
1385
1386 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
1387 {
1388 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1389
1390 HALAUDIO_ERROR("%s QUERY ClientCounter=%u\r\n", __FUNCTION__, pAUDIOShared->g_u32ClientCounter);
1391
1392 if (pAUDIOShared->g_u32ClientCounter == 0)
1393 {
1394 HALAUDIO_ERROR("Resume from Suspend mode, reset Audio SHM data ...\n");
1395 }
1396 }
1397 else
1398 {
1399 HALAUDIO_ERROR("create Audio SHM data ...\n");
1400
1401 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
1402 {
1403 HALAUDIO_ERROR("Audio SHM data is created\n");
1404 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
1405
1406 HALAUDIO_ERROR("reset Audio SHM data ...\n");
1407 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1408 }
1409 else
1410 {
1411 HALAUDIO_ERROR("AUDIO SHM allocation failed!\n");
1412 return NULL;
1413 }
1414 }
1415
1416 if (g_bInitShmFlag == FALSE)
1417 {
1418 g_bInitShmFlag = TRUE;
1419 pAUDIOShared->g_u32ClientCounter++;
1420 }
1421
1422 HALAUDIO_ERROR("End %s InitShmFlag=%d, ClientCounter=%u \r\n", __FUNCTION__, g_bInitShmFlag, pAUDIOShared->g_u32ClientCounter);
1423
1424 #else
1425 pAUDIOShared = &g_audioShared;
1426
1427 if (g_bInitShmFlag == FALSE)
1428 {
1429 HALAUDIO_PRINT("create Audio SHM data ...\n");
1430 g_bInitShmFlag = TRUE;
1431
1432 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1433
1434 pAUDIOShared->g_u32ClientCounter++;
1435 }
1436 #endif
1437
1438 gOpenDecodeSystemFuncPtr = HAL_AUDIO_OpenDecodeSystem;
1439 gDigitalOutChannelStatusFuncPtr = HAL_AUDIO_DigitalOut_SetChannelStatus;
1440 pFuncPtr_Setsystem = HAL_AUDIO_SetDecodeSystem;
1441 gGetDDRInfoFuncPtr = HAL_AUDIO_GetDDRInfo;
1442
1443 return pAUDIOShared;
1444 }
1445
HAL_AUDIO_DeAllocateVars(void)1446 MS_BOOL HAL_AUDIO_DeAllocateVars(void)
1447 {
1448 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
1449
1450 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
1451 MS_U32 u32ShmId = 0;
1452 AUDIO_SHARED_VARS2 *virtAddr = 0;
1453 MS_U32 u32BufSize = 0;
1454
1455 HALAUDIO_ERROR("Start HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1456
1457 if (g_bInitShmFlag == TRUE)
1458 {
1459 g_bInitShmFlag = FALSE;
1460
1461 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
1462 {
1463 HALAUDIO_ERROR("%s() : No AUDIO SHM is created!\n", __FUNCTION__);
1464 return FALSE;
1465 }
1466
1467 pAUDIOShared = (AUDIO_SHARED_VARS2 *)virtAddr;
1468 pAUDIOShared->g_u32ClientCounter--;
1469
1470 HALAUDIO_ERROR("HAL_AUDIO_DeAllocateVars ClientCounter=%u\r\n", pAUDIOShared->g_u32ClientCounter);
1471
1472 if (pAUDIOShared->g_u32ClientCounter == 0)
1473 {
1474 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1475
1476 HALAUDIO_ERROR("free Audio SHM data ...\n");
1477 #if defined(MSOS_TYPE_LINUX)
1478 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_SHM_NAME, u32ShmId) == TRUE)
1479 {
1480 HALAUDIO_ERROR("Audio SHM data is freed\n");
1481 }
1482 else
1483 {
1484 HALAUDIO_ERROR("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1485 return FALSE;
1486 }
1487 #endif
1488
1489 HAL_AUDIO_Mutex_DeInit();
1490 }
1491 /* patch for DC off/on no sound issue start */
1492 else
1493 {
1494 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
1495 }
1496 /* patch for DC off/on no sound issue end */
1497 }
1498
1499 HALAUDIO_ERROR("End HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
1500 #else
1501 pAUDIOShared = &g_audioShared;
1502
1503 if (g_bInitShmFlag == TRUE)
1504 {
1505 HALAUDIO_PRINT("free Audio SHM data ...\n");
1506 g_bInitShmFlag = FALSE;
1507
1508 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
1509 }
1510 #endif
1511
1512 return TRUE;
1513 }
1514
1515 ////////////////////////////////////////////////////////////////////////////////
1516 /// @brief \b Function \b Name: HAL_AUDIO_InitialVars()
1517 /// @brief \b Function \b Description: This routine set audio share memory of Aduio module.
1518 /// @param <IN> \b NONE :
1519 /// @param <OUT> \b NONE :
1520 /// @param <RET> \b NONE :
1521 /// @param <GLOBAL> \b NONE :
1522 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_InitialVars(void)1523 MS_BOOL HAL_AUDIO_InitialVars(void)
1524 {
1525 if (HAL_AUDIO_GET_INIT_FLAG() == FALSE)
1526 {
1527 g_AudioVars2 = HAL_AUDIO_AllocateVars();
1528 if (g_AudioVars2 == NULL)
1529 {
1530 return FALSE;
1531 }
1532
1533 #ifndef MSOS_TYPE_NUTTX
1534 pAudioTeeInfoShm = HAL_AUDIO_AllocateTeeInfoShm();
1535 if (pAudioTeeInfoShm == NULL)
1536 {
1537 HALAUDIO_ERROR("Create Audio TEE INFO SHM data fail...\n");
1538 return FALSE;
1539 }
1540 }
1541 #else
1542 {
1543 MS_U8 audio_mbx_class=0;
1544
1545 MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "MAD", (MS_U8 *)&audio_mbx_class);
1546 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(audio_mbx_class, 10, HAL_AUDIO_HandleDynamicMBX))
1547 {
1548 HALAUDIO_ERROR("MAD Register MBX MSG error\n");
1549 return FALSE;
1550 }
1551 else
1552 DBG_AUDIO("MAD MBX register msg ok %d\n", audio_mbx_class);
1553
1554 _s32MadEventId = MsOS_CreateEventGroup("MAD_Event");
1555 if (_s32MadEventId < 0)
1556 {
1557 HALAUDIO_ERROR("MAD CreateEventGroup error....\n");
1558 return FALSE;
1559 }
1560
1561 _s32MadTaskId = MsOS_CreateTask((TaskEntry)_MAD_Proc,
1562 NULL,
1563 E_TASK_PRI_MEDIUM,
1564 TRUE,
1565 NULL,
1566 32, // stack size..
1567 "MAD_ISR_Task");
1568 if (_s32MadTaskId < 0)
1569 {
1570 MsOS_DeleteEventGroup(_s32MadEventId);
1571 HALAUDIO_ERROR("MAD CreateTask error....\n");
1572 return FALSE;
1573 }
1574 }
1575 }
1576 #endif
1577
1578 return TRUE;
1579 }
1580
1581 ////////////////////////////////////////////////////////////////////////////////
1582 /// @brief \b Function \b Name: HAL_AUDIO_DeInitialVars()
1583 /// @brief \b Function \b Description: This routine delete audio share memory of Aduio module.
1584 /// @param <IN> \b NONE :
1585 /// @param <OUT> \b NONE :
1586 /// @param <RET> \b NONE :
1587 /// @param <GLOBAL> \b NONE :
1588 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DeInitialVars(void)1589 MS_BOOL HAL_AUDIO_DeInitialVars(void)
1590 {
1591 MS_BOOL ret = TRUE;
1592
1593 if (HAL_AUDIO_GET_INIT_FLAG() == TRUE)
1594 {
1595 HAL_AUDIO_SET_INIT_FLAG(FALSE);
1596
1597 ret = HAL_AUDIO_DeAllocateVars();
1598 if (ret == FALSE)
1599 {
1600 HALAUDIO_ERROR ("%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
1601 }
1602
1603 #if 0 /* patch for STR resume segmentation fault issue */
1604 g_AudioVars2 = NULL;
1605 #endif
1606
1607 #ifndef MSOS_TYPE_NUTTX
1608 {
1609 MS_BOOL ret1;
1610
1611 ret1 = HAL_AUDIO_DeAllocateTeeInfoShm();
1612 if (ret1 == FALSE)
1613 {
1614 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
1615 ret = FALSE;
1616 }
1617 }
1618 #endif
1619 }
1620
1621 return ret;
1622 }
1623
1624 ////////////////////////////////////////////////////////////////////////////////
1625 /// @brief \b Function \b Name: HAL_AUDIO_SET_INIT_FLAG()
1626 /// @brief \b Function \b Description: This routine set the initial status of Aduio module.
1627 /// @param <IN> \b NONE :
1628 /// @param <OUT> \b NONE :
1629 /// @param <RET> \b MS_BOOL :
1630 /// @param <GLOBAL> \b NONE :
1631 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)1632 void HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)
1633 {
1634 HALAUDIO_CHECK_SHM_INIT;
1635
1636 g_AudioVars2->g_Audio_InitFlag = bSet;
1637
1638 return;
1639 }
1640
1641 ////////////////////////////////////////////////////////////////////////////////
1642 /// @brief \b Function \b Name: HAL_AUDIO_GET_INIT_FLAG()
1643 /// @brief \b Function \b Description: This routine get the initial status of Aduio module.
1644 /// @param <IN> \b NONE :
1645 /// @param <OUT> \b NONE :
1646 /// @param <RET> \b MS_BOOL :
1647 /// @param <GLOBAL> \b NONE :
1648 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GET_INIT_FLAG(void)1649 MS_BOOL HAL_AUDIO_GET_INIT_FLAG(void)
1650 {
1651 if (g_AudioVars2 == NULL)
1652 {
1653 return FALSE;
1654 }
1655
1656 return g_AudioVars2->g_Audio_InitFlag;
1657 }
1658
1659 ////////////////////////////////////////////////////////////////////////////////
1660 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_Init()
1661 /// @brief \b Function \b Description: This routine is the initialization of Mutex for Audio module.
1662 /// @param <IN> \b NONE :
1663 /// @param <OUT> \b NONE :
1664 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
1665 /// @param <GLOBAL> \b NONE :
1666 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_Init(void)1667 MS_BOOL HAL_AUDIO_Mutex_Init(void)
1668 {
1669 MS_BOOL ret = TRUE;
1670
1671 if ((_s32AUDIOMutex != -1) &&
1672 (_s32AUDIOMutexReboot != -1) &&
1673 (_s32MutexLoadCode != -1) &&
1674 (_s32AUDIOMutexIDMA != -1))
1675 {
1676 return ret;
1677 }
1678
1679 if (_s32AUDIOMutex == -1)
1680 {
1681 _s32AUDIOMutex = OS_CREATE_MUTEX(AUDIO);
1682 if (_s32AUDIOMutex == -1)
1683 {
1684 HALAUDIO_ERROR("Error! Create Mutex failed!\n");
1685 ret = FALSE;
1686 }
1687 }
1688
1689 if (_s32AUDIOMutexReboot == -1)
1690 {
1691 _s32AUDIOMutexReboot = OS_CREATE_MUTEX(AUDIOreboot);
1692 if (_s32AUDIOMutexReboot == -1)
1693 {
1694 HALAUDIO_ERROR("Error! Create Mutex for Reboot failed!\n");
1695 ret = FALSE;
1696 }
1697 }
1698
1699 if (_s32MutexLoadCode == -1)
1700 {
1701 _s32MutexLoadCode = OS_CREATE_MUTEX(LOAD_DECDSP);
1702 if (_s32MutexLoadCode == -1)
1703 {
1704 HALAUDIO_ERROR("Error! Create Mutex for Load DSP failed!\n");
1705 ret = FALSE;
1706 }
1707 }
1708
1709 if (_s32AUDIOMutexIDMA == -1)
1710 {
1711 _s32AUDIOMutexIDMA = OS_CREATE_MUTEX(AUDIO_IDMA);
1712 if (_s32AUDIOMutexIDMA == -1)
1713 {
1714 HALAUDIO_ERROR("Error! Create Mutex for IMDA failed!\n");
1715 ret = FALSE;
1716 }
1717 }
1718
1719 if (ret == FALSE)
1720 {
1721 if (_s32AUDIOMutex != -1)
1722 {
1723 OS_DELETE_MUTEX(_s32AUDIOMutex);
1724 _s32AUDIOMutex = -1;
1725 }
1726
1727 if (_s32AUDIOMutexReboot != -1)
1728 {
1729 OS_DELETE_MUTEX(_s32AUDIOMutexReboot);
1730 _s32AUDIOMutexReboot = -1;
1731 }
1732
1733 if (_s32MutexLoadCode != -1)
1734 {
1735 OS_DELETE_MUTEX(_s32MutexLoadCode);
1736 _s32MutexLoadCode = -1;
1737 }
1738
1739 if (_s32AUDIOMutexIDMA != -1)
1740 {
1741 OS_DELETE_MUTEX(_s32AUDIOMutexIDMA);
1742 _s32AUDIOMutexIDMA = -1;
1743 }
1744 }
1745
1746 return ret;
1747 }
1748
1749 ////////////////////////////////////////////////////////////////////////////////
1750 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_DeInit()
1751 /// @brief \b Function \b Description: This routine is the deletion of Mutex for Audio module.
1752 /// @param <IN> \b NONE :
1753 /// @param <OUT> \b NONE :
1754 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
1755 /// @param <GLOBAL> \b NONE :
1756 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_DeInit(void)1757 MS_BOOL HAL_AUDIO_Mutex_DeInit(void)
1758 {
1759 MS_BOOL ret = TRUE;
1760
1761 if ((_s32AUDIOMutex == -1) &&
1762 (_s32AUDIOMutexReboot == -1) &&
1763 (_s32MutexLoadCode == -1) &&
1764 (_s32AUDIOMutexIDMA == -1))
1765 {
1766 return ret;
1767 }
1768
1769 if (_s32AUDIOMutex != -1)
1770 {
1771 if (OS_DELETE_MUTEX(_s32AUDIOMutex) != TRUE)
1772 {
1773 HALAUDIO_ERROR("Error! Delete Mutex failed!\n");
1774 ret = FALSE;
1775 }
1776 _s32AUDIOMutex = -1;
1777 }
1778
1779 if (_s32AUDIOMutexReboot != -1)
1780 {
1781 if (OS_DELETE_MUTEX(_s32AUDIOMutexReboot) != TRUE)
1782 {
1783 HALAUDIO_ERROR("Error! Delete Mutex for Reboot failed!\n");
1784 ret = FALSE;
1785 }
1786 _s32AUDIOMutexReboot = -1;
1787 }
1788
1789 if (_s32MutexLoadCode != -1)
1790 {
1791 if (OS_DELETE_MUTEX(_s32MutexLoadCode) != TRUE)
1792 {
1793 HALAUDIO_ERROR("Error! Delete Mutex for Load DSP failed!\n");
1794 ret = FALSE;
1795 }
1796 _s32MutexLoadCode = -1;
1797 }
1798
1799 if (_s32AUDIOMutexIDMA != -1)
1800 {
1801 if (OS_DELETE_MUTEX(_s32AUDIOMutexIDMA) != TRUE)
1802 {
1803 HALAUDIO_ERROR("Error! Delete Mutex for IMDA failed!\n");
1804 ret = FALSE;
1805 }
1806 _s32AUDIOMutexIDMA = -1;
1807 }
1808
1809 return ret;
1810 }
1811
1812 ////////////////////////////////////////////////////////////////////////////////
1813 /// @brief \b Function \b Name: HAL_AUDIO_GetChipType() @@Cathy
1814 /// @brief \b Function \b Description: This routine is used to get the IC version for API.
1815 /// @param <IN> \b NONE :
1816 /// @param <OUT> \b NONE :
1817 /// @param <RET> \b AU_CHIP_TYPE :
1818 /// @param <GLOBAL> \b NONE :
1819 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetChipType(void)1820 AU_CHIP_TYPE HAL_AUDIO_GetChipType(void)
1821 {
1822 return AU_CHIP_MONACO;
1823 }
1824
1825 ////////////////////////////////////////////////////////////////////////////////
1826 /// @brief \b Function \b Name: HAL_AUDIO_Set_MMIO_BASE() @@Cathy
1827 /// @brief \b Function \b Description: This routine is used to set MMIO base
1828 /// @param <IN> \b u32_MMIO_MapBase :
1829 /// @param <OUT> \b NONE :
1830 /// @param <RET> \b :
1831 /// @param <GLOBAL> \b NONE :
1832 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)1833 void HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)
1834 {
1835 _gMIO_MapBase = _MMIO_MapBase; // Get the absolute MMIO address
1836 }
1837
1838 //-------------------------------------------------------------------------------------------------
1839 // Global Functions
1840 //-------------------------------------------------------------------------------------------------
1841
1842 ////////////////////////////////////////////////////////////////////////////////
1843 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadByte @@Cathy
1844 /// @brief \b Function \b Description: read 1 Byte data
1845 /// @param <IN> \b u32RegAddr: register address
1846 /// @param <OUT> \b None :
1847 /// @param <RET> \b MS_U8 : 8-bit register value
1848 /// @param <GLOBAL> \b None :
1849 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)1850 MS_U8 HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)
1851 {
1852 return (_AU_AbsReadByte((u32RegAddr-0x100000)));
1853 }
1854
1855 ////////////////////////////////////////////////////////////////////////////////
1856 /// @brief \b Function \b Name: HAL_AUDIO_ReadByte @@Cathy
1857 /// @brief \b Function \b Description: read 1 Byte data
1858 /// @param <IN> \b u32RegAddr: register address
1859 /// @param <OUT> \b None :
1860 /// @param <RET> \b MS_U8 : 8-bit register value
1861 /// @param <GLOBAL> \b None :
1862 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)1863 MS_U8 HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)
1864 {
1865 return (_AU_AbsReadByte(u32RegAddr+0x010000)); // Add audio bank offset
1866 }
1867
1868
1869 ////////////////////////////////////////////////////////////////////////////////
1870 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadReg @@Cathy
1871 /// @brief \b Function \b Description: read 2 Byte data
1872 /// @param <IN> \b u32RegAddr: register address
1873 /// @param <OUT> \b None :
1874 /// @param <RET> \b MS_U16 : 16-bit register value
1875 /// @param <GLOBAL> \b None :
1876 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)1877 MS_U16 HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)
1878 {
1879 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1880 return _AU_AbsRead2Byte((u32RegAddr-0x100000)); // Add audio bank offset
1881 }
1882
1883 ////////////////////////////////////////////////////////////////////////////////
1884 /// @brief \b Function \b Name: HAL_AUDIO_ReadReg @@Cathy
1885 /// @brief \b Function \b Description: read 2 Byte data
1886 /// @param <IN> \b u32RegAddr: register address
1887 /// @param <OUT> \b None :
1888 /// @param <RET> \b MS_U16 : 16-bit register value
1889 /// @param <GLOBAL> \b None :
1890 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)1891 MS_U16 HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)
1892 {
1893 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1894 return (_AU_AbsRead2Byte(u32RegAddr+0x010000)); // Add audio bank offset
1895 }
1896
1897 ////////////////////////////////////////////////////////////////////////////////
1898 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteReg
1899 /// @brief \b Function \b Description: write 2 Byte data
1900 /// @param <IN> \b u32RegAddr: register address
1901 /// @param <IN> \b u16Val : 2 byte data
1902 /// @param <OUT> \b None :
1903 /// @param <RET> \b None :
1904 /// @param <GLOBAL> \b None :
1905 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)1906 void HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
1907 {
1908 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1909 _AU_AbsWrite2Byte((u32RegAddr-0x100000),u16Val); // Add audio bank offset
1910 }
1911
1912 ////////////////////////////////////////////////////////////////////////////////
1913 /// @brief \b Function \b Name: HAL_AUDIO_WriteReg @@Cathy
1914 /// @brief \b Function \b Description: write 2 Byte data
1915 /// @param <IN> \b u32RegAddr: register address
1916 /// @param <IN> \b u16Val : 2 byte data
1917 /// @param <OUT> \b None :
1918 /// @param <RET> \b None :
1919 /// @param <GLOBAL> \b None :
1920 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)1921 void HAL_AUDIO_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
1922 {
1923 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1924 _AU_AbsWrite2Byte((u32RegAddr+0x010000),u16Val); // Add audio bank offset
1925 }
1926
1927 ////////////////////////////////////////////////////////////////////////////////
1928 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteByte
1929 /// @brief \b Function \b Description: write 1 Byte data
1930 /// @param <IN> \b u32RegAddr: register address
1931 /// @param <IN> \b u8Val : 1 byte data
1932 /// @param <OUT> \b None :
1933 /// @param <RET> \b None :
1934 /// @param <GLOBAL> \b None :
1935 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)1936 void HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
1937 {
1938 _AU_AbsWriteByte((u32RegAddr-0x100000), u8Val); // Add audio bank offset
1939 }
1940
1941 ////////////////////////////////////////////////////////////////////////////////
1942 /// @brief \b Function \b Name: HAL_AUDIO_WriteByte @@Cathy
1943 /// @brief \b Function \b Description: write 1 Byte data
1944 /// @param <IN> \b u32RegAddr: register address
1945 /// @param <IN> \b u8Val : 1 byte data
1946 /// @param <OUT> \b None :
1947 /// @param <RET> \b None :
1948 /// @param <GLOBAL> \b None :
1949 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)1950 void HAL_AUDIO_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
1951 {
1952 _AU_AbsWriteByte((u32RegAddr+0x010000), u8Val); // Add audio bank offset
1953 }
1954
1955 ////////////////////////////////////////////////////////////////////////////////
1956 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskByte @@Morris
1957 /// @brief \b Function \b Description: Mask write 8-bit data
1958 /// @param <IN> \b u32RegAddr: register address
1959 /// @param <IN> \b u16Val : 8-bit data
1960 /// @param <OUT> \b None :
1961 /// @param <RET> \b None :
1962 /// @param <GLOBAL> \b None :
1963 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)1964 void HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
1965 {
1966 _AU_AbsWriteMaskByte((u32RegAddr-0x100000), u8Mask, u8Val);
1967 }
1968
1969 ////////////////////////////////////////////////////////////////////////////////
1970 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskByte @@Cathy
1971 /// @brief \b Function \b Description: Mask write 8-bit data
1972 /// @param <IN> \b u32RegAddr: register address
1973 /// @param <IN> \b u16Val : 8-bit data
1974 /// @param <OUT> \b None :
1975 /// @param <RET> \b None :
1976 /// @param <GLOBAL> \b None :
1977 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)1978 void HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
1979 {
1980 _AU_AbsWriteMaskByte((u32RegAddr+0x010000), u8Mask, u8Val); // Add audio bank offset
1981 }
1982
1983 ////////////////////////////////////////////////////////////////////////////////
1984 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskReg
1985 /// @brief \b Function \b Description: Mask write 16-bit data
1986 /// @param <IN> \b u32RegAddr: register address
1987 /// @param <IN> \b u16Val : 16-bit data
1988 /// @param <OUT> \b None :
1989 /// @param <RET> \b None :
1990 /// @param <GLOBAL> \b None :
1991 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)1992 void HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
1993 {
1994 MS_U16 u16RegVal;
1995
1996 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
1997 u16RegVal = _AU_AbsRead2Byte((u32RegAddr-0x100000));
1998 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
1999 _AU_AbsWrite2Byte((u32RegAddr-0x100000), u16RegVal);
2000 }
2001
2002 ////////////////////////////////////////////////////////////////////////////////
2003 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskReg @@Cathy
2004 /// @brief \b Function \b Description: Mask write 16-bit data
2005 /// @param <IN> \b u32RegAddr: register address
2006 /// @param <IN> \b u16Val : 16-bit data
2007 /// @param <OUT> \b None :
2008 /// @param <RET> \b None :
2009 /// @param <GLOBAL> \b None :
2010 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2011 void HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2012 {
2013 MS_U16 u16RegVal;
2014
2015 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2016 u16RegVal = HAL_AUDIO_ReadReg(u32RegAddr);
2017 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2018 HAL_AUDIO_WriteReg(u32RegAddr, u16RegVal);
2019 }
2020
2021 ////////////////////////////////////////////////////////////////////////////////
2022 /// @brief \b Function \b Name: _HAL_AUDIO_Write4Byte @@Cathy
2023 /// @brief \b Function \b Description: write 4 Byte data
2024 /// @param <IN> \b u32RegAddr: register address
2025 /// @param <IN> \b u32Val : 4 byte data
2026 /// @param <OUT> \b None :
2027 /// @param <RET> \b None :
2028 /// @param <GLOBAL> \b None :
2029 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)2030 void _HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
2031 {
2032 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+0x010000] =(MS_U16) (u32Val&0xFFFF);
2033 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+2+0x010000] =(MS_U16) (u32Val>>16);
2034 }
2035
2036 ////////////////////////////////////////////////////////////////////////////////
2037 /// @brief \b Function \b Name: HAL_AUDIO_ReadMailBox() @@Need_Modify
2038 /// @brief \b Function \b Description: This routine is used to read the Dec or SE DSP mail box value
2039 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2040 /// @param <IN> \b u8ParamNum : Mail box address
2041 /// @param <OUT> \b NONE :
2042 /// @param <RET> \b U16 : Mail Box value
2043 /// @param <GLOBAL> \b NONE :
2044 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum)2045 MS_U16 HAL_AUDIO_ReadMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum)
2046 {
2047 MS_U16 u16Tmp1, u16Tmp2;
2048 MS_U32 i, u32MailReg;
2049
2050
2051 for (i=0; i<1000; i++)
2052 {
2053 if(bDspType==DSP_SE)
2054 {
2055 if(u8ParamNum<8)
2056 {
2057 u32MailReg = 0x2D70+(MS_U32)u8ParamNum * 2;
2058 }
2059 else
2060 {
2061 u32MailReg = REG_SE_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2062 }
2063 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2064 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2065 }
2066 else
2067 {
2068 if(u8ParamNum<8)
2069 {
2070 u32MailReg = 0x2D60+(MS_U32)u8ParamNum * 2;
2071 }
2072 else
2073 {
2074 u32MailReg = REG_DEC_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2075 }
2076 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2077 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2078 }
2079 if(u16Tmp1==u16Tmp2)
2080 {
2081 return u16Tmp1;
2082 }
2083 }
2084
2085 printf("Read Mailbox fail! \r\n");
2086 return 0;
2087
2088 }
2089
2090 ////////////////////////////////////////////////////////////////////////////////
2091 /// @brief \b Function \b Name: HAL_AUDIO_WriteDecMailBox() @@Need_Modify
2092 /// @brief \b Function \b Description: This routine is used to write Dec-DSP mail box
2093 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2094 /// @param <IN> \b u8ParamNum : Mail box address
2095 /// @param <IN> \b u16Data : value
2096 /// @param <OUT> \b NONE :
2097 /// @param <RET> \b NONE :
2098 /// @param <GLOBAL> \b NONE :
2099 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum,MS_U16 u16Data)2100 void HAL_AUDIO_WriteMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum, MS_U16 u16Data)
2101 {
2102 MS_U32 u32MailReg;
2103
2104 if(bDspType==DSP_SE)
2105 {
2106 u32MailReg = REG_SE_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2107 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2108 }
2109 else
2110 {
2111 u32MailReg = REG_DEC_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2112 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2113 }
2114 }
2115
2116
2117 ///-----------------------------------------------------------------------------
2118 ////////////////////////////////////////////////////////////////////////////////
2119 ////////////////////////////////////////////////////////////////////////////////
2120 ///
2121 /// AUDIO Initialize Relational Hal Function
2122 ///
2123 ////////////////////////////////////////////////////////////////////////////////
2124
2125 ////////////////////////////////////////////////////////////////////////////////
2126 ///-----------------------------------------------------------------------------
2127 ////////////////////////////////////////////////////////////////////////////////
2128 /// @brief \b Function \b Name: HAL_AUDIO_WriteInitTable() @@Cathy
2129 /// @brief \b Function \b Description: This function is used to write initial register table(8-bit mode)
2130 /// @param <IN> \b NONE :
2131 /// @param <OUT> \b NONE :
2132 /// @param <RET> \b NONE :
2133 /// @param <GLOBAL> \b NONE :
2134 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteInitTable(void)2135 void HAL_AUDIO_WriteInitTable(void)
2136 {
2137 MS_U16 i = 0;
2138 MS_U16 j = 0;
2139
2140 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2141 {
2142 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2143 {
2144 if(ResetDMIOTbl[j].u16Mask == 1)
2145 {
2146 if(ResetDMIOTbl[j].u16Value!=0)
2147 MsOS_DelayTask((MS_U32)(ResetDMIOTbl[j].u16Value));
2148 }
2149 }
2150 else
2151 {
2152 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2153 }
2154
2155 j++;
2156 }
2157
2158 if (HAL_AUDIO_CheckBootOnInitState() == FALSE)
2159 {
2160 while( !((AudioInitTbl_0[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_0[i].u8Mask == 0)) )
2161 {
2162 if((AudioInitTbl_0[i].u32Addr == 0xFFFFFF))
2163 {
2164 if(AudioInitTbl_0[i].u8Mask == 1)
2165 {
2166 if(AudioInitTbl_0[i].u8Value!=0)
2167 MsOS_DelayTask((MS_U32)(AudioInitTbl_0[i].u8Value));
2168 }
2169 }
2170 else
2171 {
2172 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_0[i].u32Addr, AudioInitTbl_0[i].u8Mask, AudioInitTbl_0[i].u8Value);
2173 }
2174
2175 i++;
2176 }
2177 }
2178
2179 i = 0;
2180 while( !((AudioInitTbl_1[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_1[i].u8Mask == 0)) )
2181 {
2182 if((AudioInitTbl_1[i].u32Addr == 0xFFFFFF))
2183 {
2184 if(AudioInitTbl_1[i].u8Mask == 1)
2185 {
2186 if(AudioInitTbl_1[i].u8Value!=0)
2187 MsOS_DelayTask((MS_U32)(AudioInitTbl_1[i].u8Value));
2188 }
2189 }
2190 else
2191 {
2192 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_1[i].u32Addr, AudioInitTbl_1[i].u8Mask, AudioInitTbl_1[i].u8Value);
2193 }
2194
2195 i++;
2196 }
2197
2198 // Set I2S RX synthesizer reference clock for different IC revision of U01, U02, U03
2199 if( SYS_GetChipRev() == 0x2) // IC = U03
2200 {
2201 HAL_AUDIO_WriteMaskByte(0x2CAF, 0xE0, 0x80); // 0x112CAE[15:13] = 0x4
2202 }
2203 else if(SYS_GetChipRev() <= 0x1) // IC = U01, U02
2204 {
2205 HAL_AUDIO_WriteMaskByte(0x2CAF, 0xE0, 0x20); // 0x112CAE[15:13] = 0x1
2206 }
2207
2208 }
2209
2210 ////////////////////////////////////////////////////////////////////////////////
2211 /// @brief \b Function \b Name: HAL_AUDIO_WritePreInitTable()
2212 /// @brief \b Function \b Description: This function is used to set power on DAC sequence before setting init table.
2213 /// @param <IN> \b NONE :
2214 /// @param <OUT> \b NONE :
2215 /// @param <RET> \b NONE :
2216 /// @param <GLOBAL> \b NONE :
2217 ////////////////////////////////////////////////////////////////////////////////
2218 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_WritePreInitTable(void)2219 void HAL_AUDIO_WritePreInitTable(void)
2220 {
2221 MS_U16 i = 0;
2222
2223 if (HAL_AUDIO_CheckBootOnInitState() == TRUE)
2224 {
2225 return;
2226 }
2227
2228 while( !((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock[i].u8Mask == 0)) )
2229 {
2230 if((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF))
2231 {
2232 if(AudioPreInitTbl_Clock[i].u8Mask == 1)
2233 {
2234 if(AudioPreInitTbl_Clock[i].u8Value!=0)
2235 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock[i].u8Value));
2236 }
2237 }
2238 else
2239 {
2240 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock[i].u32Addr, AudioPreInitTbl_Clock[i].u8Mask, AudioPreInitTbl_Clock[i].u8Value);
2241 }
2242 i++;
2243 }
2244 }
2245
2246 ////////////////////////////////////////////////////////////////////////////////
2247 /// @brief \b Function \b Name: HAL_AUDIO_WriteStopDecTable()
2248 /// @brief \b Function \b Description: This function is used to set stop command to R2/DSP.
2249 /// @param <IN> \b NONE :
2250 /// @param <OUT> \b NONE :
2251 /// @param <RET> \b NONE :
2252 /// @param <GLOBAL> \b NONE :
2253 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteStopDecTable(void)2254 void HAL_AUDIO_WriteStopDecTable(void)
2255 {
2256 MS_U16 i = 0;
2257
2258 while( !((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF) && (Audio_stopDecTbl[i].u8Mask == 0)) )
2259 {
2260 if((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF))
2261 {
2262 if(Audio_stopDecTbl[i].u8Mask == 1)
2263 {
2264 if(Audio_stopDecTbl[i].u8Value!=0)
2265 MsOS_DelayTask((MS_U32)(Audio_stopDecTbl[i].u8Value));
2266 }
2267 }
2268 else
2269 {
2270 HAL_AUDIO_AbsWriteMaskByte(Audio_stopDecTbl[i].u32Addr, Audio_stopDecTbl[i].u8Mask, Audio_stopDecTbl[i].u8Value);
2271 }
2272 i++;
2273 }
2274 }
2275
2276 ////////////////////////////////////////////////////////////////////////////////
2277 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2278 /// @brief \b Function \b Description: This function is used to enable earphone low power stage.
2279 /// @param <IN> \b NONE :
2280 /// @param <OUT> \b NONE :
2281 /// @param <RET> \b NONE :
2282 /// @param <GLOBAL> \b NONE :
2283 ////////////////////////////////////////////////////////////////////////////////
2284 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_LowPower_Stage(void)2285 void HAL_AUDIO_EnaEarphone_LowPower_Stage(void)
2286 {
2287
2288 return;
2289 }
2290
2291 ////////////////////////////////////////////////////////////////////////////////
2292 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
2293 /// @brief \b Function \b Description: This function is used to enable earphone high driving stage.
2294 /// @param <IN> \b NONE :
2295 /// @param <OUT> \b NONE :
2296 /// @param <RET> \b NONE :
2297 /// @param <GLOBAL> \b NONE :
2298 ////////////////////////////////////////////////////////////////////////////////
2299 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)2300 void HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)
2301 {
2302 return;
2303 }
2304
2305 ////////////////////////////////////////////////////////////////////////////////
2306 /// @brief \b Function \b Name: HAL_AUDIO_SetPowerOn() @@Need_Modify
2307 /// @brief \b Function \b Description: This routine is used to execute DSP power on/down setting.
2308 /// @param <IN> \b bPower_on : TRUE --power on
2309 /// FALSE--power off
2310 /// @param <OUT> \b NONE :
2311 /// @param <RET> \b NONE :
2312 /// @param <GLOBAL> \b NONE :
2313 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)2314 void HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)
2315 {
2316 DBG_AUDIO("HAL_AUDIO_SetPowerOn(%x)\r\n", bPower_on);
2317 if(bPower_on)
2318 {
2319 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x00); // DSP power up command, DO NOT touch bit3
2320 HAL_AUDIO_WriteMaskByte(0x2B42, 0xFF, 0x00); // Disable BB by-pass
2321 }
2322 else
2323 {
2324 g_AudioVars2->g_Audio_PreInitFlag = FALSE;
2325 HAL_AUDIO_SET_INIT_FLAG(FALSE);
2326
2327 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x02); // DSP power down command
2328 AUDIO_DELAY1MS(100);
2329
2330 // Disable MIU Request for DEC-DSP
2331 HAL_MAD_Dis_MIUREQ();
2332
2333 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00); // SPDIF power down
2334 }
2335 }
2336
2337 ////////////////////////////////////////////////////////////////////////////////
2338 /// @brief \b Function \b Name: HAL_AUDIO_ADCInit() @@Cathy
2339 /// @brief \b Function \b Description: This routine is ADC relational register Init.
2340 /// @param <IN> \b NONE :
2341 /// @param <OUT> \b NONE :
2342 /// @param <RET> \b NONE :
2343 /// @param <GLOBAL> \b NONE :
2344 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ADCInit(void)2345 void HAL_AUDIO_ADCInit(void)
2346 {
2347 HAL_AUDIO_WriteMaskByte(0x2CDA, 0x03, 0x00); // power on ADC0 & ADC1
2348 HAL_AUDIO_WriteMaskByte(0x2CEE, 0x03, 0x03); //enable ADC dither
2349 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00); // power on ADC PGA
2350 HAL_AUDIO_WriteMaskByte(0x2CE5, 0xFC, 0x00); //ADC0 & ADC1 PGAain=0dB
2351 }
2352
2353 ////////////////////////////////////////////////////////////////////////////////
2354 /// @brief \b Function \b Name: HAL_AUDIO_SwResetMAD() @@Cathy
2355 /// @brief \b Function \b Description: This function is used to software reset MAD
2356 /// @param <IN> \b NONE :
2357 /// @param <OUT> \b NONE :
2358 /// @param <RET> \b NONE :
2359 /// @param <GLOBAL> \b NONE :
2360 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SwResetMAD(void)2361 void HAL_AUDIO_SwResetMAD(void)
2362 {
2363 MS_U16 j = 0;
2364
2365 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2366 {
2367 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2368 {
2369 if(ResetDMIOTbl[j].u16Mask == 1)
2370 {
2371 if(ResetDMIOTbl[j].u16Value!=0)
2372 AUDIO_DELAY1MS((MS_U32)(ResetDMIOTbl[j].u16Value));
2373 }
2374 }
2375 else
2376 {
2377 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2378 }
2379
2380 j++;
2381 }
2382
2383 /* Audio software engine reset */
2384 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
2385 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2386 AUDIO_DELAY1MS(1);
2387 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0F);
2388 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2389 AUDIO_DELAY1MS(1);
2390 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
2391 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
2392 AUDIO_DELAY1MS(1);
2393 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x00);
2394 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x00);
2395 AUDIO_DELAY1MS(1);
2396 }
2397
2398 ////////////////////////////////////////////////////////////////////////////////
2399 /// @brief \b Function \b Name: HAL_AUDIO_ResetDSP() @@Cathy
2400 /// @brief \b Function \b Description: This function is used to reset DSP.
2401 /// @param <IN> \b NONE :
2402 /// @param <OUT> \b NONE :
2403 /// @param <RET> \b NONE :
2404 /// @param <GLOBAL> \b NONE :
2405 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ResetDSP(void)2406 void HAL_AUDIO_ResetDSP(void)
2407 {
2408 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x02); // Reset DSP
2409 AUDIO_DELAY1MS(2);
2410 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x03);
2411 }
2412
2413 ////////////////////////////////////////////////////////////////////////////////
2414 /// @brief \b Function \b Name: HAL_AUDIO_DecDspISR() @@Need_Modify
2415 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2416 /// @param <IN> \b NONE :
2417 /// @param <OUT> \b NONE :
2418 /// @param <RET> \b NONE :
2419 /// @param <GLOBAL> \b NONE :
2420 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecDspISR(void)2421 void HAL_AUDIO_DecDspISR(void) //Cathy need modify
2422 {
2423 MS_U8 dec_ISR_cmdType;
2424
2425 dec_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_DEC_ISRCMD);
2426
2427 HALAUDIO_CHECK_SHM_INIT;
2428
2429 if(dec_ISR_cmdType == 0x3)
2430 {
2431 g_AudioVars2->g_bDecPlayFileFlag = TRUE;
2432 }
2433 else if(dec_ISR_cmdType == 0x13) // MPEG encode ISR
2434 {
2435 HAL_AUDIO_SetEncodeDoneFlag(1); // for PVR encode done, kochien modified
2436 EncBuf_Count++; // remaining data in buffer
2437 EncFrameIdx += 16; //default 16 frames / interrupt
2438 MPEG_EN_BUF[EncBuf_W_idx].u32Addr = ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINEADDR))*16;
2439 MPEG_EN_BUF[EncBuf_W_idx].u32Size= ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINESIZE))*16;
2440 MPEG_EN_BUF[EncBuf_W_idx].u64Idx= (MS_U64)EncFrameIdx; //(MS_U64)(((EncFrameIdx-1)*1152*90)/48);
2441
2442 if(EncBuf_W_idx == 5)// (ENC_BUF_SIZE-1)) // circular buffer // manually circular...
2443 EncBuf_W_idx = 0;
2444 else
2445 EncBuf_W_idx++;
2446 }
2447 else if (dec_ISR_cmdType == 0x07) // 2nd Decoder ISR in MM
2448 {
2449 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2450 }
2451 }
2452
2453 ////////////////////////////////////////////////////////////////////////////////
2454 /// @brief \b Function \b Name: HAL_AUDIO_SeDspISR() @@Need_Modify
2455 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2456 /// @param <IN> \b NONE :
2457 /// @param <OUT> \b NONE :
2458 /// @param <RET> \b NONE :
2459 /// @param <GLOBAL> \b NONE :
2460 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeDspISR(void)2461 void HAL_AUDIO_SeDspISR(void)
2462 {
2463 MS_U8 se_ISR_cmdType;
2464
2465 se_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_SE_ISRCMD);
2466
2467 /* add for PIP ASND Decode */
2468 if ( se_ISR_cmdType == 0x03 )
2469 {
2470 if (g_AudioVars2 != NULL)
2471 {
2472 g_AudioVars2->g_bSePlayFileFlag = TRUE;
2473 }
2474 }
2475 }
2476
2477 ////////////////////////////////////////////////////////////////////////////////
2478 /// @brief \b Function \b Name: HAL_AUDIO_SetPlayFileFlag() @Cathy
2479 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2480 /// @param <IN> \b NONE :
2481 /// @param <OUT> \b NONE :
2482 /// @param <RET> \b NONE :
2483 /// @param <GLOBAL> \b NONE :
2484 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType,MS_BOOL bSet)2485 void HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType, MS_BOOL bSet)
2486 {
2487 HALAUDIO_CHECK_SHM_INIT;
2488
2489 if(bDspType == DSP_DEC)
2490 {
2491 g_AudioVars2->g_bDecPlayFileFlag = bSet;
2492 }
2493 else
2494 {
2495 g_AudioVars2->g_bSePlayFileFlag = bSet;
2496 }
2497 }
2498
2499 ////////////////////////////////////////////////////////////////////////////////
2500 /// @brief \b Function \b Name: HAL_AUDIO_GetPlayFileFlag() @@Cathy
2501 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2502 /// @param <IN> \b NONE :
2503 /// @param <OUT> \b NONE :
2504 /// @param <RET> \b NONE :
2505 /// @param <GLOBAL> \b NONE :
2506 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)2507 MS_BOOL HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)
2508 {
2509 MS_U32 es_rdPtr, es_wrPtr;
2510 MS_S32 es_level, es_bufSz, es_freeSpace;
2511 MS_U32 es_reqSize;
2512 MS_U8 r2_dec_id;
2513
2514 if (bDspType ==DSP_DEC)
2515 r2_dec_id = ADEC1;
2516 else if(bDspType ==DSP_SE)
2517 r2_dec_id = ADEC2;
2518 else
2519 r2_dec_id = ADEC1; //default case
2520
2521 es_rdPtr = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, r2_dec_id );
2522 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM( R2_SHM_PARAM_ES_WR_PTR, r2_dec_id, 0 );
2523 es_reqSize = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, r2_dec_id);
2524
2525 es_bufSz = ES1_DRAM_SIZE;
2526 es_level = es_wrPtr - es_rdPtr;
2527
2528 if (es_level < 0)
2529 es_level += es_bufSz;
2530
2531 es_freeSpace = es_bufSz - es_level;
2532
2533 if ( es_freeSpace > es_reqSize )
2534 return TRUE;
2535 else
2536 return FALSE;
2537 }
2538
2539 ////////////////////////////////////////////////////////////////////////////////
2540 /// @brief \b Function \b Name: HAL_AUDIO_SetEncodeDoneFlag() @@Cathy
2541 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
2542 /// @param <IN> \b NONE :
2543 /// @param <OUT> \b NONE :
2544 /// @param <RET> \b NONE :
2545 /// @param <GLOBAL> \b NONE :
2546 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)2547 void HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)
2548 {
2549 if (bSet)
2550 g_bEncodeDoneFlag= 1;
2551 else
2552 g_bEncodeDoneFlag = 0;
2553 }
2554
2555 ////////////////////////////////////////////////////////////////////////////////
2556 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeDoneFlag() @@Cathy
2557 /// @brief \b Function \b Description: This function is used to get the Encoder flag status
2558 /// @param <IN> \b NONE :
2559 /// @param <OUT> \b NONE :
2560 /// @param <RET> \b NONE :
2561 /// @param <GLOBAL> \b NONE :
2562 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeDoneFlag(void)2563 MS_BOOL HAL_AUDIO_GetEncodeDoneFlag(void)
2564 {
2565 return g_bEncodeDoneFlag;
2566 }
2567
2568 ////////////////////////////////////////////////////////////////////////////////
2569 /// @brief \b Function \b Name: HAL_AUDIO_CheckBootOnInitState()
2570 /// @brief \b Function \b Description: This routine is used to check whether mboot load init script
2571 /// @param void
2572 /// @return MS_U16 \b : Mail Box value
2573 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckBootOnInitState(void)2574 MS_BOOL HAL_AUDIO_CheckBootOnInitState(void)
2575 {
2576 if ((HAL_AUDIO_ReadByte(REG_AUDIO_AUDIO_INIT_CHECK) & 0x1) == 0)
2577 {
2578 return FALSE;
2579 }
2580 else
2581 {
2582 return TRUE;
2583 }
2584 }
2585
2586 /////////////////////////////////////////////////////////////////////////////////
2587 /// ///
2588 /// AUDIO I/O Config Relational Hal Function ///
2589 /// ///
2590 ////////////////////////////////////////////////////////////////////////////////
2591
2592 ////////////////////////////////////////////////////////////////////////////////
2593 /// @brief \b Function \b Name: HAL_AUDIO_GetPathGroup()
2594 /// @brief \b Function \b Description: This routine is used to get Audio path group type .
2595 /// @param output \b : Audio output path-group type
2596 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPathGroup(void)2597 AUDIO_PATH_GROUP_TYPE HAL_AUDIO_GetPathGroup(void)
2598 {
2599 // AUDIO_PATH_GROUP_1 : U3, Janus
2600 // AUDIO_PATH_GROUP_2 : T3, U4, T8, T9, T12, T13, J2
2601 return(AUDIO_PATH_GROUP_2);
2602 }
2603
2604 ////////////////////////////////////////////////////////////////////////////////
2605 /// @brief \b Function \b Name: HAL_AUDIO_SetNormalPath() @@ No used in T3 @@VVV
2606 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input and Output.
2607 /// @param <IN> \b u8Path : Audio DSP channel
2608 /// @param <IN> \b input : Audio input type
2609 /// @param <IN> \b output : Audio output type
2610 /// @param <OUT> \b NONE :
2611 /// @param <RET> \b NONE :
2612 /// @param <GLOBAL> \b NONE :
2613 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path,AUDIO_INPUT_TYPE input,AUDIO_OUTPUT_TYPE output)2614 void HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path, AUDIO_INPUT_TYPE input, AUDIO_OUTPUT_TYPE output)
2615 {
2616 u8Path=u8Path;
2617 input=input;
2618 output=output;
2619 }
2620
2621 ////////////////////////////////////////////////////////////////////////////////
2622 /// @brief \b Function \b Name: HAL_AUDIO_SetInputPath() @@VVV
2623 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input .
2624 /// @param <IN> \b input : Audio input type
2625 /// @param <IN> \b u8Path : Audio DSP channel
2626 /// @param <OUT> \b NONE :
2627 /// @param <RET> \b NONE :
2628 /// @param <GLOBAL> \b NONE :
2629 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input,AUDIO_PATH_TYPE u8Path)2630 void HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input , AUDIO_PATH_TYPE u8Path)
2631 {
2632 MS_U32 u32path_reg;
2633 MS_U8 u8input_src, u8input_idx, u8temp, path;
2634 AUDIO_INPUT_TYPE input1; // define this in order to do more check for ATV input source.
2635 input1 = input;
2636
2637 if((input == AUDIO_NULL_INPUT) || (u8Path ==AUDIO_PATH_NULL))
2638 {
2639 return;
2640 }
2641
2642 u8input_src = LONIBBLE(input);
2643 u8input_idx = HINIBBLE(input);
2644
2645 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
2646 {
2647 input1 = AUDIO_DSP4_SIF_INPUT;
2648 u8input_src = LONIBBLE(input1);
2649 }
2650
2651 if( u8Path == AUDIO_PATH_MAIN )
2652 {
2653 if (u8input_src == AUDIO_ADC_INPUT || u8input_src == AUDIO_ADC2_INPUT)
2654 {
2655 HAL_SOUND_EnableDcRemove(TRUE);
2656 }
2657 else
2658 {
2659 HAL_SOUND_EnableDcRemove(FALSE);
2660 }
2661 }
2662
2663 path=(MS_U8)u8Path;
2664
2665 /* save main speaker audio input */
2666 if( u8Path == AUDIO_PATH_MAIN )
2667 {
2668 g_audioSrcType = input1;
2669 }
2670 /* save sub channel audio input */
2671 else if( u8Path == AUDIO_PATH_6 )
2672 {
2673 g_audioSubSrcType = input1;
2674 }
2675
2676 if( path >= (sizeof(u32PathArray)/sizeof(u32PathArray[0])))
2677 {
2678 DBG_AUDIO("DSP is not support more than CH8\n");
2679 return;
2680 }
2681
2682 u32path_reg = u32PathArray[path];
2683
2684 // Set input
2685 switch(u8input_src)
2686 {
2687 case AUDIO_DSP1_INPUT:
2688 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x80);
2689 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG, 0x07,u8input_idx); // Set main parser source
2690 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx); // Set AD parser source
2691 break;
2692
2693 case AUDIO_DSP2_INPUT:
2694 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x81);
2695 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx);
2696 break;
2697
2698 case AUDIO_DSP3_INPUT:
2699 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x82);
2700 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x07,u8input_idx);
2701 break;
2702
2703 case AUDIO_DSP4_INPUT:
2704 /*
2705 * A patch here!
2706 * Just a temporary solution to hardcode channel 7 to 0x90 for HW DMA Reader2,
2707 */
2708 if (u8input_idx == 0x7)
2709 {
2710 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x83);
2711 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER4_CFG, 0x07,u8input_idx);
2712 } else {
2713 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x90);
2714 }
2715 break;
2716
2717 case AUDIO_ADC_INPUT:
2718 if(u8input_idx==0x0A)
2719 u8temp=0x40;
2720 else if(u8input_idx==0x0B)
2721 u8temp=0x50;
2722 else
2723 u8temp = (u8input_idx<<4);
2724 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x08);
2725 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, u8temp );
2726 break;
2727
2728 case AUDIO_ADC2_INPUT:
2729 if(u8input_idx==0x0A)
2730 u8temp=0x04;
2731 else if(u8input_idx==0x0B)
2732 u8temp=0x05;
2733 else
2734 u8temp = u8input_idx;
2735 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x09);
2736 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp );
2737 break;
2738
2739 case AUDIO_SPDIF_INPUT:
2740 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x86);
2741 break;
2742
2743 case AUDIO_I2S_INPUT:
2744 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x85);
2745 break;
2746
2747 case AUDIO_HDMI_INPUT:
2748 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x8F, 0x84);
2749 break;
2750
2751 case AUDIO_DMA_INPUT:
2752 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x0F, 0x0F);
2753 break;
2754
2755 default:
2756 break;
2757 }
2758 }
2759
2760 ////////////////////////////////////////////////////////////////////////////////
2761 /// @brief \b Function \b Name: HAL_AUDIO_SetOutputPath() @@Need_Modify
2762 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2763 /// @param <IN> \b u8Path : Audio DSP channel
2764 /// @param <IN> \b output : Audio output type
2765 /// @param <OUT> \b NONE :
2766 /// @param <RET> \b NONE :
2767 /// @param <GLOBAL> \b NONE :
2768 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2769 void HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2770 {
2771 u8Path=u8Path;
2772 u8Output=u8Output;
2773 }
2774
2775 ////////////////////////////////////////////////////////////////////////////////
2776 /// @brief \b Function \b Name: HAL_AUDIO_SetInternalPath() @@VVV
2777 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
2778 /// @param <IN> \b u8Path : Audio internal path
2779 /// @param <IN> \b output : Audio output type
2780 /// @param <OUT> \b NONE :
2781 /// @param <RET> \b NONE :
2782 /// @param <GLOBAL> \b NONE :
2783 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)2784 void HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
2785 {
2786 MS_U8 path;
2787 // OUT0, OUT1, OUT2 , OUT3 , S/PDIF, I2S, HP , Dummy
2788 MS_U8 BalanceBitMap[8]={ 0, 1, 2, 3, 8, 4, 1, 7 };
2789
2790 if(u8Path >= INTERNAL_MAX_NUM)
2791 return;
2792
2793 path = (MS_U8)u8Path;
2794
2795 if(u8Path==INTERNAL_PCM_SE) // Only speaker use this path
2796 {
2797 g_BalanceMask=g_BalanceMask|(0x01<<BalanceBitMap[(int)u8Output]); // Enable balance mask
2798 }
2799
2800 if((HAL_AUDIO_ReadByte(M2S_MBOX_BALANCE_EN+1)&0x80)!=0)
2801 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
2802 else
2803 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000); // Balance disable
2804
2805 // Set output
2806 switch(u8Output)
2807 {
2808 case AUDIO_AUOUT0_OUTPUT:
2809 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0x0F, path);
2810 break;
2811
2812 case AUDIO_AUOUT1_OUTPUT:
2813 case AUDIO_HP_OUTPUT:
2814 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0xF0, (path<<4));
2815 break;
2816
2817 case AUDIO_AUOUT2_OUTPUT:
2818 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0x0F, path);
2819 break;
2820
2821 case AUDIO_AUOUT3_OUTPUT:
2822 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0xF0, (path<<4));
2823 break;
2824
2825 case AUDIO_I2S_OUTPUT:
2826 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0x0F, path);
2827 break;
2828
2829 case AUDIO_SPDIF_OUTPUT:
2830 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3+1, 0x0F, path); // Fix PCM in
2831 break;
2832
2833 case AUDIO_I2S2_OUTPUT:
2834 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0xF0, (path<<4));
2835 break;
2836
2837 default:
2838 break;
2839 }
2840
2841 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_SPK_OutChannel, g_AudioVars2->AudioPathInfo.SpeakerOut, DSP_MEM_TYPE_PM); // INFO DSP SPK Output channel
2842 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_HP_OutChannel, g_AudioVars2->AudioPathInfo.HpOut, DSP_MEM_TYPE_PM); // INFO DSP HP Output channel
2843 }
2844
2845
2846 ////////////////////////////////////////////////////////////////////////////////
2847 /// @brief \b Function \b Name: HAL_AUDIO_FwTriggerDSP() @@Need_Modify
2848 /// @brief \b Function \b Description: This routine send a PIO11 interrupt to DSP with a command on 0x2D34.
2849 /// @param <IN> \b cmd : 0xF0-- for MHEG5 file protocol
2850 /// @param <OUT> \b NONE :
2851 /// @param <RET> \b NONE :
2852 /// @param <GLOBAL> \b NONE :
2853 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd)2854 void HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd) //Cathy need modify
2855 {
2856 u16Cmd = u16Cmd;
2857 }
2858
2859 ////////////////////////////////////////////////////////////////////////////////
2860 /// @brief \b Function \b Name: HAL_AUDIO_DspBootOnDDR()
2861 /// @brief \b Function \b Description: Enable DSP load / reload code from DDR
2862 /// @param <IN> \b bEnable : 0 -- load code from FLASH
2863 /// 1 -- load code from DDR
2864 /// @param <OUT> \b NONE :
2865 /// @param <RET> \b NONE :
2866 /// @param <GLOBAL> \b NONE :
2867 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)2868 void HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)
2869 {
2870 g_bAudio_loadcode_from_dram = bEnable;
2871 }
2872
2873 ////////////////////////////////////////////////////////////////////////////////
2874 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
2875 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
2876 /// @param <IN> \b NONE :
2877 /// @param <OUT> \b NONE :
2878 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
2879 /// @param <GLOBAL> \b NONE :
2880 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetIsDtvFlag(void)2881 MS_BOOL HAL_AUDIO_GetIsDtvFlag(void)
2882 {
2883 return g_bIsDTV;
2884 }
2885
2886 ////////////////////////////////////////////////////////////////////////////////
2887 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
2888 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
2889 /// @param <IN> \b NONE :
2890 /// @param <OUT> \b NONE :
2891 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
2892 /// @param <GLOBAL> \b NONE :
2893 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)2894 void HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)
2895 {
2896 g_bIsDTV=bIsDTV;
2897 }
2898
2899 ////////////////////////////////////////////////////////////////////////////////
2900 /// @brief \b Function \b Name: HAL_AUDIO_Dec_Status() @@Cathy
2901 /// @brief \b Function \b Description: This routine is used to read the Decoder status.
2902 /// @param <IN> \b NONE :
2903 /// @param <OUT> \b NONE :
2904 /// @param <RET> \b MS_U8 : Decoder Status
2905 /// @param <GLOBAL> \b NONE :
2906 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Dec_Status(void)2907 MS_U8 HAL_AUDIO_Dec_Status(void)
2908 {
2909 return(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD));
2910 }
2911
2912 ////////////////////////////////////////////////////////////////////////////////
2913 /// @brief \b Function \b Name: HAL_AUDIO_Enc_Status() @@Kochien.Kuo
2914 /// @brief \b Function \b Description: This routine is used to read the Encoder status.
2915 /// @param <IN> \b NONE :
2916 /// @param <OUT> \b NONE :
2917 /// @param <RET> \b MS_U8 : Encoder Status
2918 /// @param <GLOBAL> \b NONE :
2919 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Enc_Status(void)2920 MS_U8 HAL_AUDIO_Enc_Status(void)
2921 {
2922 return(HAL_AUDIO_ReadByte(REG_DEC_ENCODE_CMD));
2923 }
2924
2925 ////////////////////////////////////////////////////////////////////////////////
2926 /// @brief \b Function \b Name: HAL_AUDIO_SE_Status() @@Cathy
2927 /// @brief \b Function \b Description: This routine is used to read the SE status.
2928 /// @param <IN> \b NONE :
2929 /// @param <OUT> \b NONE :
2930 /// @param <RET> \b MS_U8 : Decoder Status
2931 /// @param <GLOBAL> \b NONE :
2932 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Se_Status(void)2933 MS_U8 HAL_AUDIO_Se_Status(void)
2934 {
2935 return(HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD));
2936 }
2937
2938 ////////////////////////////////////////////////////////////////////////////////
2939 /// @brief \b Function \b Name: HAL_AUDIO_Set_Fading() @@Need_Modify
2940 /// @brief \b Function \b Description: This routine is used to set the Fading response time
2941 /// @param <IN> \b u32VolFading : Fading response time parameter
2942 /// @param <OUT> \b NONE :
2943 /// @param <RET> \b NONE :
2944 /// @param <GLOBAL> \b NONE :
2945 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)2946 void HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)
2947 {
2948 HAL_MAD2_Write_DSP_sram(0x114C, u32VolFading, DSP_MEM_TYPE_PM); //need touch
2949 }
2950
2951
2952 ////////////////////////////////////////////////////////////////////////////////
2953 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetUploadRate() @@Need_Modify
2954 /// @brief \b Function \b Description: According Blue tooth upload path, for different sampling rate setting the Synthesizer.
2955 /// @param <IN> \b bEnable : 0 -- Disable Blue Tooth upload
2956 /// 1 -- Enable Blue Tooth upload
2957 /// @param <IN> \b u8Samprate: Sampling Rate
2958 /// 0--no change
2959 /// 1--48KHz
2960 /// 2--44KHz
2961 /// 3--32KHz
2962 /// @param <OUT> \b NONE :
2963 /// @param <RET> \b NONE :
2964 /// @param <GLOBAL> \b NONE :
2965 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)2966 void HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)
2967 {
2968 u8Samprate &= 0x0003;
2969
2970 if(bEnable)
2971 {
2972 HAL_AUDIO_DecWriteByte(0x2C5A, 0x55);
2973 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0x10);
2974 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,u8Samprate);
2975 }
2976 else
2977 {
2978 HAL_AUDIO_DecWriteByte(0x2C5A, 0);
2979 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0);
2980 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,0);
2981 }
2982 }
2983
2984
2985 ////////////////////////////////////////////////////////////////////////////////
2986 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetBufferCounter() @@Need_Modify
2987 /// @brief \b Function \b Description: Set the DDR buffer according the sampling rate and the frame time
2988 /// @param <IN> \b u32Counter : if the sampling rate is 48KHz, the frame time is 40ms
2989 /// ==> the frame buffer size is 48000*0x04*2 (L/R) *2(Bytes/sample) = 0x1E00
2990 /// the counter is 0x1E00/8 = 960 (For 1*Burst DMA)
2991 /// @param <OUT> \b NONE :
2992 /// @param <RET> \b NONE :
2993 /// @param <GLOBAL> \b NONE :
2994 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)2995 void HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)
2996 {
2997 u32Counter &= 0x00FFFFFF;
2998 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_btFrameSize, u32Counter, DSP_MEM_TYPE_PM);
2999 }
3000
3001 ////////////////////////////////////////////////////////////////////////////////
3002 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_Enable() @@Need_Modify
3003 /// @brief \b Function \b Description: Enable/ Disable the path of USB PCM
3004 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
3005 /// @param <OUT> \b NONE :
3006 /// @param <RET> \b NONE :
3007 /// @param <GLOBAL> \b NONE :
3008 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)3009 void HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)
3010 {
3011 //this funcion is removed from DSP
3012 UNUSED(bEnable);
3013 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3014 }
3015
3016
3017 ////////////////////////////////////////////////////////////////////////////////
3018 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetFlag() @@Need_Modify
3019 /// @brief \b Function \b Description: Get interrupt flag for USBPCM function
3020 /// \b (Encoder path)
3021 /// @param <IN> \b NONE :
3022 /// @param <OUT> \b NONE :
3023 /// @param <RET> \b BOOL : interrupt flag
3024 /// @param <GLOBAL> \b NONE :
3025 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetFlag()3026 MS_BOOL HAL_AUDIO_USBPCM_GetFlag()
3027 {
3028 //this funcion is removed from DSP
3029 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3030 return 0;
3031 }
3032
3033 ////////////////////////////////////////////////////////////////////////////////
3034 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_SetFlag() @@Need_Modify
3035 /// @brief \b Function \b Description: clear interrupt flag for USBPCM function
3036 /// \b (Encoder path)
3037 /// @param <IN> \b bEnable : set false to clean interrupt flag
3038 /// @param <OUT> \b NONE :
3039 /// @param <RET> \b NONE :
3040 /// @param <GLOBAL> \b NONE :
3041 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)3042 void HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)
3043 {
3044 //this funcion is removed from DSP
3045 UNUSED(bEnable);
3046 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3047 }
3048
3049 ////////////////////////////////////////////////////////////////////////////////
3050 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetMemInfo() @@Need_Modify
3051 /// @brief \b Function \b Description: Get memory address and size for USBPCM function
3052 /// \b (Encoder path)
3053 /// @param <IN> \b NONE :
3054 /// @param <OUT> \b MS_U32 : address, size
3055 /// @param <RET> \b NONE :
3056 /// @param <GLOBAL> \b NONE :
3057 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO * uploadInfo)3058 void HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO *uploadInfo)
3059 {
3060 //this funcion is removed from DSP
3061 HALAUDIO_ERROR("%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3062 }
3063
3064 ////////////////////////////////////////////////////////////////////////////////
3065 /// @brief \b Function \b Name: HAL_AUDIO_ I2S_SetMode() @@Need_Modify
3066 /// @brief \b Function \b Description: This routine is used to Set the I2S output mode.
3067 /// @param <IN> \b Mode : MCLK , WORD_WIDTH , SOURCE_CH , FORMAT
3068 /// @param <IN> \b Value : Please reference the register table 0x2C8C & 0x2C8D .
3069 /// @param <OUT> \b NONE :
3070 /// @param <RET> \b NONE :
3071 /// @param <GLOBAL> \b NONE :
3072 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode,MS_U8 u8Val)3073 void _HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode, MS_U8 u8Val)
3074 {
3075 switch(u8Mode)
3076 {
3077 case AUDIO_I2S_MCLK: //0x2C8C[6:4]
3078 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x70,u8Val<<4);
3079 break;
3080
3081 case AUDIO_I2S_WORD_WIDTH: //0x2C8C[2:0]
3082 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x07,u8Val);
3083 break;
3084
3085 case AUDIO_I2S_FORMAT: //0x2C8C[3]
3086 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x08,u8Val<<3);
3087 break;
3088
3089 case AUDIO_I2S_SOURCE_CH:
3090 // No need ; Only select Group A in T3 .
3091 break;
3092
3093 case AUDIO_I2S_RXMODE:
3094 if(u8Val==I2S_SLAVE_MODE) //slave mode
3095 { //0x2C8C[2], 2CAE[13], 2CCE[15:13][1:0]
3096 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x00);
3097 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0x00);
3098 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0x20);
3099 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x00);
3100 }
3101 else //master mode
3102 {
3103 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x04);
3104 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0xA0);
3105 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0xC0);
3106 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x03);
3107 }
3108 break;
3109
3110 case AUDIO_I2S_TXMODE:
3111 // Tx always Master Mode;
3112 break;
3113
3114 default:
3115 break;
3116 }
3117 }
3118
3119
3120
HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType,MS_BOOL bEnable)3121 static void HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType, MS_BOOL bEnable)
3122 {
3123 switch(eType)
3124 {
3125 case DD_DDCO:
3126 if(bEnable == TRUE)
3127 {
3128 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x1 );
3129 }
3130 else
3131 {
3132 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x0 );
3133 }
3134 break;
3135
3136 case DD_DDENCODE:
3137 if(bEnable == TRUE)
3138 {
3139 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x2 );
3140 }
3141 else
3142 {
3143 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x0 );
3144 }
3145 break;
3146
3147 case DTS_ENCODE_2CH:
3148 case DTS_ENCODE_MULTI:
3149 case MP3_ENCODE:
3150 default:
3151 HALAUDIO_ERROR("%s() - Choosen Encoder not exist\n",__FUNCTION__);
3152 break;
3153 }
3154 }
3155
HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DSP_ID eDspID)3156 static void HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DSP_ID eDspID)
3157 {
3158 switch (ePath)
3159 {
3160 case DIGITAL_SPDIF_OUTPUT:
3161 {
3162 switch(eDspID)
3163 {
3164 case AUDIO_DSP_ID_R2:
3165 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x4);
3166 break;
3167 case AUDIO_DSP_ID_SND:
3168 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x8);
3169 break;
3170 case AUDIO_DSP_ID_DEC:
3171 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x0);
3172 break;
3173 default:
3174 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3175 break;
3176 }
3177 }
3178 break;
3179
3180 case DIGITAL_HDMI_ARC_OUTPUT:
3181 {
3182 switch(eDspID)
3183 {
3184 case AUDIO_DSP_ID_R2:
3185 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3186 break;
3187 case AUDIO_DSP_ID_SND:
3188 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3189 break;
3190 case AUDIO_DSP_ID_DEC:
3191 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3192 break;
3193 default:
3194 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3195 break;
3196 }
3197 }
3198 break;
3199
3200 case DIGITAL_HDMI_OUTPUT:
3201 {
3202 switch(eDspID)
3203 {
3204 case AUDIO_DSP_ID_R2:
3205 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
3206 break;
3207 case AUDIO_DSP_ID_SND:
3208 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
3209 break;
3210 case AUDIO_DSP_ID_DEC:
3211 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
3212 break;
3213 default:
3214 HALAUDIO_ERROR("%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
3215 break;
3216 }
3217 }
3218 break;
3219
3220 default:
3221 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3222 break;
3223 }
3224
3225 }
3226
HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath,MS_BOOL bEnable)3227 static void HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath, MS_BOOL bEnable)
3228 {
3229
3230 switch(ePath)
3231 {
3232 case DIGITAL_SPDIF_OUTPUT:
3233 if(bEnable == TRUE)
3234 {
3235 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
3236 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
3237 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x2);
3238 }
3239 else
3240 {
3241 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select DSP1 */
3242 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
3243 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
3244 }
3245 break;
3246
3247 case DIGITAL_HDMI_ARC_OUTPUT:
3248 if(bEnable == TRUE)
3249 {
3250 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3251 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3252 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3253 }
3254 else
3255 {
3256 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3257 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3258 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3259 }
3260 break;
3261
3262 case DIGITAL_HDMI_OUTPUT:
3263 if(bEnable == TRUE)
3264 {
3265 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
3266 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
3267 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
3268 }
3269 else
3270 {
3271 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
3272 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
3273 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
3274 }
3275 break;
3276
3277 default:
3278 HALAUDIO_ERROR("%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
3279 break;
3280 }
3281 }
3282 ////////////////////////////////////////////////////////////////////////////////
3283 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3284 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3285 /// @param <IN> \b u8Spdif_mode :
3286 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3287 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3288 /// bit[2] = 1: non-PCM NULL Payload
3289 /// @param <IN> \b u8Input_src 0 : DTV
3290 /// 1 : ATV
3291 /// 2 : HDMI
3292 /// 3 : ADC
3293 /// 4 : CardReader
3294 /// 5 : SPDIF
3295 /// @param <OUT> \b NONE :
3296 /// @param <RET> \b NONE :
3297 /// @param <GLOBAL> \b NONE :
3298 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSetting)3299 static void HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSetting)
3300 {
3301 Digital_Out_Channel_Status_t stDigitalChannelStatus;
3302 memset(&stDigitalChannelStatus, 0x00, sizeof(Digital_Out_Channel_Status_t));
3303
3304 if (ePath == DIGITAL_SPDIF_OUTPUT)
3305 {
3306 _HAL_AUDIO_SPDIF_SetMute(TRUE);
3307 }
3308 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3309 {
3310 //TODO: Mute HDMI , ARC
3311 }
3312 else if (ePath == DIGITAL_HDMI_OUTPUT)
3313 {
3314
3315 }
3316
3317 HAL_AUDIO_DigitalOut_GetChannelStatus(ePath, &stDigitalChannelStatus);
3318
3319 switch (stDigitalOutSetting->eDigitalOutfMode)
3320 {
3321 case DIGITAL_OUT_PCM:
3322 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, FALSE);
3323 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3324 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3325
3326 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
3327 break;
3328
3329 case DIGITAL_OUT_DOLBYDIGITAL:
3330 if (stDigitalOutSetting->u8R2NonPcmSetting == 0x01)
3331 {
3332 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3333 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, TRUE);
3334 }
3335 else if (stDigitalOutSetting->u8R2NonPcmSetting == 0x02)
3336 {
3337 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3338 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, TRUE);
3339 }
3340
3341 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3342 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3343 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3344 break;
3345
3346 case DIGITAL_OUT_DTS:
3347 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3348 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3349 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3350 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3351 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3352 break;
3353
3354 case DIGITAL_OUT_AAC_LC:
3355 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
3356 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
3357 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
3358 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
3359 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
3360 break;
3361
3362 case DIGITAL_OUT_NONE:
3363 default:
3364 HALAUDIO_ERROR("%s() - Digital Mode %d not exist\n",__FUNCTION__,stDigitalOutSetting->eDigitalOutfMode);
3365 break;
3366 }
3367
3368 HAL_AUDIO_DigitalOut_SetChannelStatus(ePath, &stDigitalChannelStatus);
3369 // Restore Digital out mode
3370 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), &stDigitalOutSetting, sizeof(stDigitalOutSetting));
3371
3372 if (ePath == DIGITAL_SPDIF_OUTPUT)
3373 {
3374 if (g_AudioVars2->g_SPDIF_MuteStatus == FALSE)
3375 {
3376 _HAL_AUDIO_SPDIF_SetMute(FALSE);
3377 }
3378 }
3379 else
3380 {
3381 //TODO: um-Mute HDMI , ARC
3382 }
3383
3384 }
3385
3386
3387
3388 //static MS_BOOL HAL_AUDIO_DigitalOut_GetDataSource(AUDIO_OUTPORT_SOURCE_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE *retOutputType, AUDIO_DSP_ID *retNcmPath)
3389
HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSegtting)3390 static MS_BOOL HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSegtting)
3391 {
3392 AUDIO_DSP_CODE_TYPE SourceDspCodeType = AU_DVB_STANDARD_INVALID;
3393 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
3394 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
3395
3396 stDigitalOutSegtting->eSourceType = g_AudioVars2->eAudioSource;
3397 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3398 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3399
3400 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x , Source = %x, R2NonPcmSetting = %x\n\r", \
3401 __FUNCTION__, \
3402 stDigitalOutSegtting->eDigitalOutfMode, \
3403 stDigitalOutSegtting->u8NonPcmPath, \
3404 stDigitalOutSegtting->eSourceType, \
3405 stDigitalOutSegtting->u8R2NonPcmSetting);
3406
3407 switch (stDigitalOutSegtting->eDigitalOutfMode)
3408 {
3409 case DIGITAL_OUT_PCM:
3410 {
3411 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3412 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC;
3413 break;
3414 }
3415
3416 case DIGITAL_OUT_DOLBYDIGITAL:
3417 {
3418 switch (stDigitalOutSegtting->eSourceType)
3419 {
3420 case E_AUDIO_INFO_HDMI_IN:
3421 {
3422 if (bIsNonPCMInDec2)
3423 {
3424 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) &&
3425 (Dsp2CodeType == AU_DVB_STANDARD_AC3 || Dsp2CodeType == AU_DVB_STANDARD_AC3P))
3426 {
3427 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP2 */
3428 }
3429 }
3430 else if ((Dsp1CodeType == AU_DVB_STANDARD_AC3) ||
3431 (Dsp1CodeType == AU_DVB_STANDARD_AC3P))
3432 {
3433 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3434 }
3435 break;
3436 }
3437
3438 case E_AUDIO_INFO_DTV_IN:
3439 case E_AUDIO_INFO_MM_IN:
3440 case E_AUDIO_INFO_GAME_IN:
3441 {
3442 SourceDspCodeType = Dsp1CodeType;
3443
3444 switch(SourceDspCodeType)
3445 {
3446 case AU_DVB_STANDARD_AAC:
3447 case AU_DVB_STANDARD_MS10_DDT:
3448 {
3449 if ((!MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_MS10_DDT)) &&
3450 (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DDE)))
3451 {
3452 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3453 }
3454 else
3455 {
3456 if (HAL_MAD_Read_DSP_sram(DSP1PmAddr_smpRate, DSP_MEM_TYPE_PM) == 44100)
3457 {
3458 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3459 }
3460 else
3461 {
3462 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_R2; /* R2 */
3463 stDigitalOutSegtting->u8R2NonPcmSetting = (SourceDspCodeType == AU_DVB_STANDARD_AAC) ? 0x01 : 0x02; /* DDCO : 0x2E95[0], DDEnc : 0x2E95[1] */
3464 }
3465 }
3466
3467 break;
3468 }
3469
3470 case AU_DVB_STANDARD_MS10_DDC:
3471 case AU_DVB_STANDARD_AC3:
3472 case AU_DVB_STANDARD_AC3P:
3473 {
3474 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3475 break;
3476 }
3477
3478 default:
3479 {
3480 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3481 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3482 break;
3483 }
3484
3485 }
3486
3487 break;
3488 }
3489
3490 case E_AUDIO_INFO_ATV_IN:
3491 case E_AUDIO_INFO_ADC_IN:
3492 case E_AUDIO_INFO_KTV_IN:
3493 default:
3494 {
3495 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3496 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3497 break;
3498 }
3499 }
3500 break;
3501 }
3502
3503 case DIGITAL_OUT_DTS:
3504 {
3505 switch (stDigitalOutSegtting->eSourceType)
3506 {
3507 case E_AUDIO_INFO_HDMI_IN:
3508 {
3509 if (bIsNonPCMInDec2)
3510 {
3511 if (Dsp2CodeType == AU_DVB2_STANDARD_DTS) // Need check
3512 {
3513 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
3514 }
3515 }
3516 else if (Dsp1CodeType == AU_DVB_STANDARD_DTS)
3517 {
3518 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3519 }
3520 break;
3521 }
3522
3523 case E_AUDIO_INFO_MM_IN:
3524 case E_AUDIO_INFO_GAME_IN:
3525 {
3526 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_DTS;
3527 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3528 break;
3529 }
3530
3531 default:
3532 {
3533 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3534 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3535 break;
3536 }
3537 }
3538
3539 break;
3540 }
3541
3542 case DIGITAL_OUT_AAC_LC:
3543 {
3544 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3545 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3546 break;
3547 }
3548
3549 case DIGITAL_OUT_NONE:
3550 default:
3551 {
3552 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
3553 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
3554 break;
3555 }
3556
3557 }
3558
3559 return TRUE;
3560 }
3561
3562 ////////////////////////////////////////////////////////////////////////////////
3563 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3564 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3565 /// @param <IN> \b
3566 /// @param <IN> \b
3567 /// @param <OUT> \b NONE :
3568 /// @param <RET> \b NONE :
3569 /// @param <GLOBAL> \b NONE :
3570 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)3571 void HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)
3572 {
3573
3574 HALAUDIO_CHECK_SHM_INIT;
3575
3576 //TODO: add HDMI/ARC digital out status
3577
3578 // Set Digital mode to Digital out Status structure
3579 DigitalOutSetting_t stTempDigitalOutStatus;
3580 stTempDigitalOutStatus.eDigitalOutfMode = eDigitalMode;
3581 stTempDigitalOutStatus.eSourceType = E_AUDIO_INFO_DTV_IN; // Temp initial value
3582 stTempDigitalOutStatus.u8NonPcmPath = AUDIO_DSP_ID_ALL;
3583 stTempDigitalOutStatus.u8R2NonPcmSetting = 0x00;
3584 stTempDigitalOutStatus.eGroup = E_CONNECT_NULL;
3585
3586 if (ePath == DIGITAL_SPDIF_OUTPUT)
3587 {
3588 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.SpdifOut;
3589 }
3590 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
3591 {
3592 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.ArcOut;
3593 }
3594
3595 //Determin Data Path
3596 HAL_AUDIO_DigitalOut_DetermineDataPath(ePath, &stTempDigitalOutStatus);
3597
3598 // if setting is difference to previous, set digital out mode
3599 if ((stTempDigitalOutStatus.eDigitalOutfMode != g_AudioVars2->stDigitalOutSetting[ePath].eDigitalOutfMode) ||
3600 (stTempDigitalOutStatus.eSourceType != g_AudioVars2->stDigitalOutSetting[ePath].eSourceType) ||
3601 (stTempDigitalOutStatus.u8NonPcmPath != g_AudioVars2->stDigitalOutSetting[ePath].u8NonPcmPath) ||
3602 (stTempDigitalOutStatus.u8R2NonPcmSetting != g_AudioVars2->stDigitalOutSetting[ePath].u8R2NonPcmSetting) ||
3603 (stTempDigitalOutStatus.eGroup != g_AudioVars2->stDigitalOutSetting[ePath].eGroup))
3604
3605 {
3606 printf("%s() - eDigitalOutfMode = %x, eNonPcmPath = %x\n\r", \
3607 __FUNCTION__, \
3608 stTempDigitalOutStatus.eDigitalOutfMode, \
3609 stTempDigitalOutStatus.u8NonPcmPath);
3610
3611 HAL_AUDIO_DigitalOut_SetDataPath(ePath, &stTempDigitalOutStatus);
3612 }
3613 }
3614
3615 ////////////////////////////////////////////////////////////////////////////////
3616 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3617 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3618 /// @param <IN> \b eType :
3619 /// @param <OUT> \b NONE :
3620 /// @param <RET> \b NONE :
3621 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3622 MS_BOOL HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3623 {
3624 MS_BOOL ret = FALSE;
3625
3626 HALAUDIO_CHECK_SHM_INIT;
3627
3628 switch (ePath)
3629 {
3630 case DIGITAL_SPDIF_OUTPUT:
3631 {
3632
3633 // Copy protection
3634 //C bit
3635 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3636 // L bit
3637 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3638
3639 // PCM format
3640 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3641 if(g_u32bDTSCD == 1)
3642 {
3643 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x40, 0x00);
3644 }
3645
3646 // Category
3647 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3648
3649 // Source number
3650 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3651
3652 // Channel number
3653 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3654
3655 // Sampling rate
3656 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3657
3658 // Clock precision
3659 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3660
3661 // Word Length
3662 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3663
3664 // Original sampling rate
3665 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3666
3667 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3668 {
3669 if(g_u32bDTSCD == 1)
3670 {
3671 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3672 }
3673 else
3674 {
3675 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x80);
3676 }
3677 }
3678 else
3679 {
3680 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
3681 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3682 }
3683 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00); //Tx1 Toggle bit[14]
3684 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x40);
3685 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00);
3686 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3687 break;
3688 }
3689
3690 case DIGITAL_HDMI_ARC_OUTPUT:
3691 {
3692 // Copy protection
3693 //C bit
3694 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
3695 // L bit
3696 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
3697
3698 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
3699 if(g_u32bDTSCD == 1)
3700 {
3701 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x40, 0x00);
3702 }
3703
3704 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
3705
3706 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
3707
3708 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
3709
3710 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
3711
3712 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
3713
3714 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
3715
3716 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
3717
3718 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
3719 {
3720 if(g_u32bDTSCD == 1)
3721 {
3722 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3723 }
3724 else
3725 {
3726 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x80);
3727 }
3728 }
3729 else
3730 {
3731 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
3732 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
3733 }
3734
3735 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x00); //Tx2 Toggle bit[12]
3736 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x10);
3737 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x00);
3738 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
3739 break;
3740 }
3741
3742 default:
3743 {
3744 HALAUDIO_ERROR("%s() - Invalid SPDIF Path\n",__FUNCTION__);
3745 break;
3746 }
3747 }
3748
3749 return ret;
3750 }
3751
3752 ////////////////////////////////////////////////////////////////////////////////
3753 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
3754 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
3755 /// @param <IN> \b eType :
3756 /// @param <OUT> \b NONE :
3757 /// @param <RET> \b NONE :
3758 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)3759 MS_BOOL HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
3760 {
3761 MS_BOOL ret = FALSE;
3762
3763 HALAUDIO_CHECK_SHM_INIT;
3764
3765 if (stChannelStatus == NULL)
3766 {
3767 HALAUDIO_ERROR("%s() : stChannelStatus shouldn't be NULL !!!\n", __FUNCTION__);
3768 }
3769 else
3770 {
3771 memcpy(stChannelStatus, &(g_AudioVars2->stDigitalOutChannelStatus[ePath]), sizeof(Digital_Out_Channel_Status_t));
3772 ret = TRUE;
3773 }
3774
3775 return ret;
3776 }
3777
3778 ///-----------------------------------------------------------------------------
3779 ////////////////////////////////////////////////////////////////////////////////
3780 ////////////////////////////////////////////////////////////////////////////////
3781 ///
3782 /// AUDIO SPDIF Relational Hal Function
3783 ///
3784 ////////////////////////////////////////////////////////////////////////////////
3785 ////////////////////////////////////////////////////////////////////////////////
3786 ///-----------------------------------------------------------------------------
3787 ////////////////////////////////////////////////////////////////////////////////
3788 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_HWEN() @@Cathy
3789 /// @brief \b Function \b Description: This routine is used to enable S/PDIF output (Hardware)
3790 /// @param <IN> \b bEnable: 0--Disable S/PDIF out
3791 /// 1--Enable S/PDIF out
3792 /// @param <OUT> \b NONE :
3793 /// @param <RET> \b NONE :
3794 /// @param <GLOBAL> \b NONE :
3795 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)3796 void _HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)
3797 {
3798 if(bEnable)
3799 {
3800 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x80);
3801 }
3802 else
3803 {
3804 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00);
3805 }
3806 }
3807
3808 ////////////////////////////////////////////////////////////////////////////////
3809 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_SetMute() @@KH
3810 /// @brief \b Function \b Description: This routine is used to mute S/PDIF output(by DSP)
3811 /// @param <IN> \b bEnMute : 0--Disable mute
3812 /// 1--Enable mute
3813 /// @param <OUT> \b NONE :
3814 /// @param <RET> \b NONE :
3815 /// @param <GLOBAL> \b NONE :
3816 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)3817 void _HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)
3818 {
3819 MS_U8 spdif_timecnt = 0;
3820
3821 if (bEnMute == TRUE)
3822 {
3823 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
3824 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x01); // Software mute
3825 }
3826 else
3827 {
3828 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x00); // Software unmute
3829 for (spdif_timecnt = 0; spdif_timecnt < 30; spdif_timecnt++)
3830 {
3831 AUDIO_DELAY1MS(1);
3832 }
3833 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
3834 }
3835
3836 }
3837
3838 ////////////////////////////////////////////////////////////////////////////////
3839 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_ByPassChannel() @@Need_Modify
3840 /// @brief \b Function \b Description: ByPass the SPDIF channel (CH4)
3841 /// @param <IN> \b \b enable : TRUE --BYPASS CH4
3842 /// FALSE--OPEN CH4
3843 /// @param <OUT> \b NONE :
3844 /// @param <RET> \b NONE :
3845 /// @param <GLOBAL> \b NONE :
3846 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)3847 void _HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)
3848 {
3849 bEnable = bEnable;
3850 }
3851
3852 ////////////////////////////////////////////////////////////////////////////////
3853 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
3854 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
3855 /// @param <IN> \b u8Spdif_mode :
3856 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
3857 /// bit[1] = 0: PCM mode, 1: non-PCM mode
3858 /// bit[2] = 1: non-PCM NULL Payload
3859 /// @param <IN> \b u8Input_src 0 : DTV
3860 /// 1 : ATV
3861 /// 2 : HDMI
3862 /// 3 : ADC
3863 /// 4 : CardReader
3864 /// 5 : SPDIF
3865 /// @param <OUT> \b NONE :
3866 /// @param <RET> \b NONE :
3867 /// @param <GLOBAL> \b NONE :
3868 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode,MS_U8 u8Input_src)3869 void HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode, MS_U8 u8Input_src)
3870 {
3871 // Multiple npcm source, still need total rework
3872 AUDIO_SOURCE_INFO_TYPE eAudioSource = -1;
3873 MS_U8 u8SpdifMode = ((u8Spdif_mode == SPDIF_OUT_NONE) ? SPDIF_OUT_PCM : u8Spdif_mode);
3874 MS_U8 u8R2SpdifMode = (u8SpdifMode & SPDIF_OUT_PCM) ? 1 : 2;
3875 MS_U8 u8MainDecodeId = 0;
3876 AUDIO_DSP_CODE_TYPE MainDspCodeType = AU_DVB_STANDARD_INVALID;
3877 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
3878 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
3879 MS_U32 u32bDTSCD = 0;
3880 MS_U32 u32DTSTranscodeFlag = 0;
3881 MS_U8 Digital_Out_DD_Support = 0;
3882 MS_U8 Digital_Out_DDP_Support = 0;
3883 MS_U8 Digital_Out_DTS_Support = 0;
3884 MS_U8 Digital_Out_AAC_Support = 0;
3885 MS_U32 u32HDMITxSamplingRate = 0;
3886 MS_U32 u32SPDIFTxSamplingRate = 0;
3887 MS_U64 u64DecSamplingRate = 0;
3888 static MS_U32 u32bPreDTSCD = 0xFF;
3889 static MS_U32 u32PreHDMITxSamplingRate = 0;
3890 static MS_U32 u32PreSPDIFTxSamplingRate = 0;
3891
3892 HALAUDIO_CHECK_SHM_INIT;
3893
3894 UNUSED(u8Input_src);
3895 eAudioSource = g_AudioVars2->eAudioSource;
3896 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
3897 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
3898 Digital_Out_DD_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DD].support_codec;
3899 Digital_Out_DDP_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DDP].support_codec;
3900 Digital_Out_DTS_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DTS].support_codec;
3901 Digital_Out_AAC_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_AAC].support_codec;
3902
3903 MainDspCodeType = Dsp1CodeType;
3904
3905 //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);
3906
3907 /* Configure SPDIF's Output Setting */
3908 switch(eAudioSource)
3909 {
3910 case E_AUDIO_INFO_DTV_IN:
3911 case E_AUDIO_INFO_MM_IN:
3912 case E_AUDIO_INFO_GAME_IN:
3913 {
3914 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
3915 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
3916 {
3917 MainDspCodeType = Dsp2CodeType;
3918
3919 u8MainDecodeId = 1; //DEC2
3920 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC2_sampleRate);
3921 }
3922 else
3923 {
3924 u8MainDecodeId = 0; //DEC1
3925 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_sampleRate);
3926
3927 if (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_STOP)
3928 {
3929 u8SpdifMode = SPDIF_OUT_PCM;
3930 break;
3931 }
3932 }
3933
3934 switch(MainDspCodeType)
3935 {
3936 case AU_DVB_STANDARD_AAC:
3937 case AU_DVB_STANDARD_MS10_DDT:
3938 {
3939 if (g_AudioVars2->DolbyEncFlag != 1)
3940 {
3941 u8SpdifMode = SPDIF_OUT_PCM;
3942 }
3943 #if (StereoAACOutputPCM)
3944 else if (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod) == AUD_CH_MODE_STEREO)
3945 {
3946 u8SpdifMode = SPDIF_OUT_PCM;
3947 }
3948 #endif
3949 else
3950 {
3951 if ((u8SpdifMode == SPDIF_OUT_NONPCM) ||
3952 (u8SpdifMode == SPDIF_OUT_TRANSCODE))
3953 {
3954 /* 0: default, 1: support, 2: not support */
3955 if (Digital_Out_DD_Support == 2)
3956 {
3957 u8SpdifMode = SPDIF_OUT_PCM;
3958 }
3959 else if ( u64DecSamplingRate < 4) //AAC SampleRate<16k
3960 {
3961 u8SpdifMode = SPDIF_OUT_PCM;
3962 }
3963 else
3964 {
3965 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 0, 0);
3966 }
3967 }
3968 else if (u8SpdifMode == SPDIF_OUT_BYPASS) // AAC Bypass
3969 {
3970 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 1, 0);
3971 }
3972 }
3973 break;
3974 }
3975
3976 case AU_DVB_STANDARD_AC3:
3977 case AU_DVB_STANDARD_AC3P:
3978 case AU_DVB_STANDARD_MS10_DDC:
3979 {
3980 /* 0: default, 1: support, 2: not support */
3981 if (Digital_Out_DD_Support == 2)
3982 {
3983 u8SpdifMode = SPDIF_OUT_PCM;
3984 }
3985 /* 0: default, 1: support, 2: not support */
3986 else if ((Digital_Out_DDP_Support == 1) && (u8SpdifMode != SPDIF_OUT_TRANSCODE))
3987 {
3988 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
3989 }
3990 else
3991 {
3992 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
3993 }
3994 break;
3995 }
3996
3997 case AU_DVB_STANDARD_DTS:
3998 case AU_DVB_STANDARD_DTSLBR:
3999 {
4000 if (MainDspCodeType == AU_DVB_STANDARD_DTS)
4001 {
4002 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4003 }
4004
4005 /* 0: disable, 1: bypass /convert, 2: transcoder, 3: pcm */
4006 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
4007 if (u32DTSTranscodeFlag == 3)
4008 {
4009 u8SpdifMode = SPDIF_OUT_PCM;
4010 }
4011
4012 /* 0: default, 1: support, 2: not support */
4013 if (Digital_Out_DTS_Support == 2)
4014 {
4015 u8SpdifMode = SPDIF_OUT_PCM;
4016 }
4017
4018 break;
4019 }
4020
4021 default:
4022 {
4023 u8SpdifMode = SPDIF_OUT_PCM;
4024 break;
4025 }
4026 }
4027
4028 break;
4029 }
4030
4031 case E_AUDIO_INFO_ATV_IN:
4032 case E_AUDIO_INFO_ADC_IN:
4033 case E_AUDIO_INFO_KTV_IN:
4034 {
4035 u8SpdifMode = SPDIF_OUT_PCM;
4036 break;
4037 }
4038
4039 case E_AUDIO_INFO_HDMI_IN:
4040 {
4041 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
4042 {
4043 MainDspCodeType = Dsp2CodeType;
4044 u8MainDecodeId = 1; //DEC2
4045 }
4046 else
4047 {
4048 u8MainDecodeId = 0; //DEC1
4049 }
4050
4051 if (HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE)
4052 {
4053 u8SpdifMode = SPDIF_OUT_PCM;
4054 }
4055 else
4056 {
4057 switch(MainDspCodeType)
4058 {
4059 case AU_DVB_STANDARD_AC3:
4060 case AU_DVB_STANDARD_AC3P:
4061 case AU_DVB_STANDARD_MS10_DDC:
4062 {
4063 /* 0: default, 1: support, 2: not support */
4064 if (Digital_Out_DD_Support == 2)
4065 {
4066 u8SpdifMode = SPDIF_OUT_PCM;
4067 }
4068 /* 0: default, 1: support, 2: not support */
4069 else if ((Digital_Out_DDP_Support == 1) && (u8SpdifMode != SPDIF_OUT_TRANSCODE))
4070 {
4071 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
4072 }
4073 else
4074 {
4075 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
4076 }
4077 break;
4078 }
4079
4080 case AU_DVB_STANDARD_DTS:
4081 {
4082 if (MainDspCodeType == AU_DVB_STANDARD_DTS)
4083 {
4084 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
4085 }
4086
4087 /* 0: disable, 1: bypass /convert, 2: transcoder, 3: pcm */
4088 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
4089 if (u32DTSTranscodeFlag == 3)
4090 {
4091 u8SpdifMode = SPDIF_OUT_PCM;
4092 }
4093
4094 /* 0: default, 1: support, 2: not support */
4095 if (Digital_Out_DTS_Support == 2)
4096 {
4097 u8SpdifMode = SPDIF_OUT_PCM;
4098 }
4099 break;
4100 }
4101
4102 default:
4103 {
4104 u8SpdifMode = SPDIF_OUT_PCM;
4105 break;
4106 }
4107 }
4108 }
4109
4110 break;
4111 }
4112
4113 default:
4114 {
4115 HALAUDIO_ERROR("%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
4116 break;
4117 }
4118 }
4119
4120 //HALAUDIO_ERROR("%s: MainDspCodeType = %d, u8SpdifMode = %d\r\n", __FUNCTION__, MainDspCodeType, u8SpdifMode);
4121
4122 if(u8SpdifMode == SPDIF_OUT_PCM)
4123 {
4124 u32HDMITxSamplingRate = 48000;
4125 u32SPDIFTxSamplingRate = 48000;
4126 }
4127 else
4128 {
4129 u32HDMITxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, u8MainDecodeId);
4130 u32SPDIFTxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, u8MainDecodeId);
4131 }
4132
4133 if ((_HAL_AUDIO_SPDIF_GetMode() == u8SpdifMode) &&
4134 (g_AudioVars2->g_PreMainDecodeId == u8MainDecodeId) &&
4135 (g_AudioVars2->g_PreMainDspCodeType == MainDspCodeType) &&
4136 (u32PreHDMITxSamplingRate == u32HDMITxSamplingRate) &&
4137 (u32PreSPDIFTxSamplingRate == u32SPDIFTxSamplingRate))
4138 {
4139 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) ||
4140 (MainDspCodeType == AU_DVB_STANDARD_DTSLBR))
4141 {
4142 if (u32bPreDTSCD == u32bDTSCD)
4143 {
4144 /* In DTS/DTS-LBR case, if DTS-CD information is same, no need to to change SPDIF setting */
4145 return;
4146 }
4147 }
4148 else
4149 {
4150 /* No need to change SPDIF setting */
4151 return;
4152 }
4153 }
4154
4155 /* Change multi channel input source for DTS encode */
4156 if( (eAudioSource == E_AUDIO_INFO_HDMI_IN) && (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) )
4157 {
4158 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x02);
4159 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x02);
4160 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x02);
4161 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x02);
4162 }
4163 else
4164 {
4165 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, 0x00);
4166 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, 0x00);
4167 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, 0x00);
4168 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, 0x00);
4169 }
4170
4171 MS_BOOL retTx1, retTx2;
4172 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4173 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4174 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4175 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4176 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4177
4178
4179 if (retTx1 == FALSE || retTx2 == FALSE)
4180 {
4181 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4182 return;
4183 }
4184
4185 /* Mute SPDIF before changing setting */
4186 _HAL_AUDIO_SPDIF_SetMute(TRUE);
4187
4188 /* Apply UI's SPDIF setting to Audio R2 */
4189 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC1, u8R2SpdifMode, 0);
4190 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC2, u8R2SpdifMode, 0);
4191
4192 HAL_AUR2_WriteByte(REG_R2_HDMI_NONPCM_PATH, u8MainDecodeId);
4193
4194 /* Apply SPDIF's Output Setting */
4195 switch (u8SpdifMode)
4196 {
4197 case SPDIF_OUT_NONPCM:
4198 case SPDIF_OUT_BYPASS:
4199 case SPDIF_OUT_TRANSCODE:
4200 {
4201 //HALAUDIO_PRINT("HAL SPDIF set as Non-PCM\n");
4202
4203 if (u8SpdifMode == SPDIF_OUT_TRANSCODE)
4204 {
4205 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, TRUE, 0);
4206 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, TRUE, 0);
4207 }
4208 else
4209 {
4210 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
4211 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
4212 }
4213
4214 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
4215 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
4216 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4217 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4218 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4219 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4220 AUDIO_DELAY1MS(5);
4221 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x02, 0x02); /* Non-PCM */
4222
4223 break;
4224 }
4225
4226 case SPDIF_OUT_PCM:
4227 default:
4228 {
4229 //HALAUDIO_PRINT("HAL SPDIF set as PCM\n");
4230
4231 AUDIO_DELAY1MS(5);
4232 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
4233 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
4234 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
4235 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
4236 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4237 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4238 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4239
4240 break;
4241 }
4242 }
4243
4244 u32bPreDTSCD = u32bDTSCD;
4245 g_u32bDTSCD = u32bDTSCD;
4246 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4247 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4248
4249 g_AudioVars2->g_eSpdifOutputType = u8SpdifMode;
4250 g_AudioVars2->g_PreMainDecodeId = u8MainDecodeId;
4251 g_AudioVars2->g_PreMainDspCodeType = MainDspCodeType;
4252
4253 u32PreHDMITxSamplingRate = u32HDMITxSamplingRate;
4254 u32PreSPDIFTxSamplingRate = u32SPDIFTxSamplingRate;
4255 HAL_AUDIO_Set_DecimationMode(AUDIO_HDMI_ARC_OUTPUT, u8MainDecodeId);
4256 HAL_AUDIO_Set_DecimationMode(AUDIO_SPDIF_OUTPUT, u8MainDecodeId);
4257
4258 _HAL_AUDIO_SPDIF_SetMute(g_AudioVars2->g_SPDIF_MuteStatus);
4259 }
4260
4261 ////////////////////////////////////////////////////////////////////////////////
4262 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_GetMode() @@KH
4263 /// @brief \b Function \b Description: This routine is used to get S/PDIF mode.
4264 /// @param <IN> \b NONE :
4265 /// @param <OUT> \b NONE :
4266 /// @param <RET> \b BYTE : Se-DSP REG_M2D_MAILBOX_SPDIF_CTRL value
4267 /// u8Spdif_mode = 0x0 : SPDIF enable, PCM mode
4268 /// u8Spdif_mode = 0x1 : SPDIF OFF
4269 /// u8Spdif_mode = 0x2 : SPDIF enable, non-PCM mode
4270 /// @param <GLOBAL> \b NONE :
4271 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_GetMode(void)4272 MS_U8 _HAL_AUDIO_SPDIF_GetMode(void)
4273 {
4274 return g_AudioVars2->g_eSpdifOutputType;
4275 }
4276
4277 ////////////////////////////////////////////////////////////////////////////////
4278 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetSCMS()
4279 /// @brief \b Function \b Description: This routine is used to set SPDIF SCMS.
4280 /// @param C_bit_en \b : copy right control bit, register in 0x2C80[5]
4281 /// @param L_bit_en \b : generation bit, register in 0x2C82[7]
4282 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en,MS_U8 L_bit_en)4283 void HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en, MS_U8 L_bit_en)
4284 {
4285 MS_BOOL retTx1, retTx2;
4286
4287 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4288 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4289 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4290 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4291 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4292
4293 if (retTx1 == TRUE && retTx2 == TRUE)
4294 {
4295 stDigitalChannelStatusTx1.stCopyRight.CBit = C_bit_en;
4296 stDigitalChannelStatusTx1.stCopyRight.LBit = L_bit_en;
4297 stDigitalChannelStatusTx2.stCopyRight.CBit = C_bit_en;
4298 stDigitalChannelStatusTx2.stCopyRight.LBit = L_bit_en;
4299 }
4300 else
4301 {
4302 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4303 return;
4304 }
4305
4306 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4307 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4308 }
4309
4310 ////////////////////////////////////////////////////////////////////////////////
4311 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_GetSCMS()
4312 /// @brief \b Function \b Description: This routine is used to get SPDIF SCMS.
4313 /// @return MS_U8 \b : SCMS[0] = C bit status, SCMS[1] = L bit status
4314 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_GetSCMS(void)4315 MS_U8 HAL_AUDIO_SPDIF_GetSCMS(void)
4316 {
4317
4318 MS_U8 SCMS_status, SCMS_C_bit_tmp, SCMS_L_bit_tmp;
4319
4320 HALAUDIO_CHECK_SHM_INIT;
4321
4322 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.CBit)
4323 {
4324 SCMS_C_bit_tmp = 0x01;
4325 }
4326 else
4327 {
4328 SCMS_C_bit_tmp = 0x00;
4329 }
4330
4331 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.LBit)
4332 {
4333 SCMS_L_bit_tmp = 0x02;
4334 }
4335 else
4336 {
4337 SCMS_L_bit_tmp = 0x00;
4338 }
4339
4340 SCMS_status = SCMS_C_bit_tmp | SCMS_L_bit_tmp;
4341
4342 return(SCMS_status);
4343 }
4344
4345 ////////////////////////////////////////////////////////////////////////////////
4346 /// @brief \b Function \b Name: HAL_AUDIO_SetChannelStatus()
4347 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4348 /// @param <IN> \b eType :
4349 /// @param <OUT> \b NONE :
4350 /// @param <RET> \b NONE :
4351 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType,SPDIF_CS_MODE_VALUE eValue)4352 void HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType, SPDIF_CS_MODE_VALUE eValue)
4353 {
4354 MS_U8 u8Type;
4355
4356 u8Type=(MS_U8)eType;
4357
4358 MS_BOOL retTx1, retTx2;
4359 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4360 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4361 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4362 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4363 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4364
4365
4366 if (retTx1 == FALSE || retTx2 == FALSE)
4367 {
4368 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4369 return;
4370 }
4371
4372 switch(u8Type)
4373 {
4374 case SPDIF_CHANNEL_STATUS_FS:
4375 stDigitalChannelStatusTx1.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx1
4376 stDigitalChannelStatusTx2.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx2
4377 break;
4378 case SPDIF_CHANNEL_STATUS_CATEGORY:
4379 stDigitalChannelStatusTx1.u8Category = (MS_U8)eValue; // Tx1 By-pass L- bit
4380 stDigitalChannelStatusTx2.u8Category = (MS_U8)eValue; // Tx2 By-pass L- bit
4381 break;
4382 case SPDIF_CHANNEL_STATUS_PCM_FORMAT:
4383 stDigitalChannelStatusTx1.u8PcmFormatControl = (MS_U8)eValue; // Tx1 By-pass Copy right bit
4384 stDigitalChannelStatusTx2.u8PcmFormatControl = (MS_U8)eValue; // Tx2 By-pass Copy right bit
4385 break;
4386
4387 default :
4388 break;
4389 }
4390
4391 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4392 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4393 }
4394
4395 ////////////////////////////////////////////////////////////////////////////////
4396 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_ChannelStatus_CTRL()
4397 /// @brief \b Function \b Description: This routine is used to control SPDIF CS in detail.
4398 /// @return MS_U8 \b :
4399 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode,AUDIO_SPDIF_CS_TYPE_STATUS status)4400 MS_BOOL HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode, AUDIO_SPDIF_CS_TYPE_STATUS status)
4401 {
4402 MS_BOOL status_rtn = FALSE;
4403 MS_BOOL retTx1, retTx2;
4404
4405 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
4406 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
4407 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
4408 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4409 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4410
4411 if (retTx1 == FALSE || retTx2 == FALSE)
4412 {
4413 HALAUDIO_ERROR("%s() : Failed to get channel status !!!\n", __FUNCTION__);
4414 return status_rtn;
4415 }
4416
4417 switch (cs_mode)
4418 {
4419 case SPDIF_CS_CategoryCode:
4420 switch(status)
4421 {
4422 case SPDIF_CS_Category_BroadCast:
4423 stDigitalChannelStatusTx1.u8Category = 0x20;
4424 stDigitalChannelStatusTx2.u8Category = 0x20;
4425 break;
4426
4427 case SPDIF_CS_Category_General:
4428 stDigitalChannelStatusTx1.u8Category = 0x00;
4429 stDigitalChannelStatusTx2.u8Category = 0x00;
4430 break;
4431
4432 case SPDIF_CS_Category_BroadCast_JP:
4433 stDigitalChannelStatusTx1.u8Category = 0x20;
4434 stDigitalChannelStatusTx2.u8Category = 0x20;
4435 break;
4436
4437 case SPDIF_CS_Category_BroadCast_EU:
4438 stDigitalChannelStatusTx1.u8Category = 0x30;
4439 stDigitalChannelStatusTx2.u8Category = 0x30;
4440 break;
4441
4442 case SPDIF_CS_Category_BroadCast_USA:
4443 stDigitalChannelStatusTx1.u8Category = 0x26;
4444 stDigitalChannelStatusTx2.u8Category = 0x26;
4445 break;
4446
4447 default :
4448 stDigitalChannelStatusTx1.u8Category = 0x00;
4449 stDigitalChannelStatusTx2.u8Category = 0x00;
4450 break;
4451 }
4452 status_rtn = TRUE;
4453 break;
4454
4455 case SPDIF_CS_CopyRight:
4456 if(status == SPDIF_CS_CopyRight_CP)
4457 {
4458 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4459 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4460 }
4461 if(status == SPDIF_CS_CopyRight_NonCP)
4462 {
4463 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4464 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4465 }
4466 status_rtn = TRUE;
4467 break;
4468
4469 case SPDIF_CS_SourceNumber:
4470 if(status == SPDIF_CS_SourceNumber_2)
4471 {
4472 stDigitalChannelStatusTx1.u8SourceNumber = 0x40;
4473 stDigitalChannelStatusTx2.u8SourceNumber = 0x40;
4474 }
4475 if(status == SPDIF_CS_SourceNumber_5)
4476 {
4477 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4478 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4479 }
4480 if(status == SPDIF_CS_SourceNumber_6)
4481 {
4482 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
4483 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
4484 }
4485 status_rtn = TRUE;
4486 break;
4487
4488 case SPDIF_CS_ChannelNumber:
4489 if(status == SPDIF_CS_ChannelNumber_A_Left)
4490 {
4491 stDigitalChannelStatusTx1.u8ChannelNumber = 0x08;
4492 stDigitalChannelStatusTx2.u8ChannelNumber = 0x08;
4493 }
4494 if(status == SPDIF_CS_ChannelNumber_B_Right)
4495 {
4496 stDigitalChannelStatusTx1.u8ChannelNumber = 0x04;
4497 stDigitalChannelStatusTx2.u8ChannelNumber = 0x04;
4498 }
4499 if(status == SPDIF_CS_ChannelNumber_C)
4500 {
4501 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0C;
4502 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0C;
4503 }
4504 if(status == SPDIF_CS_ChannelNumber_D)
4505 {
4506 stDigitalChannelStatusTx1.u8ChannelNumber = 0x02;
4507 stDigitalChannelStatusTx2.u8ChannelNumber = 0x02;
4508 }
4509 if(status == SPDIF_CS_ChannelNumber_E)
4510 {
4511 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0A;
4512 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0A;
4513 }
4514 if(status == SPDIF_CS_ChannelNumber_F)
4515 {
4516 stDigitalChannelStatusTx1.u8ChannelNumber = 0x06;
4517 stDigitalChannelStatusTx2.u8ChannelNumber = 0x06;
4518 }
4519 status_rtn = TRUE;
4520 break;
4521
4522 case SPDIF_CS_SmpFreq:
4523 switch (status)
4524 {
4525 case SPDIF_CS_SmpFreq_192:
4526 stDigitalChannelStatusTx1.u8SamplingRate = 0x70;
4527 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
4528 break;
4529
4530 case SPDIF_CS_SmpFreq_96:
4531 stDigitalChannelStatusTx1.u8SamplingRate = 0x50;
4532 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
4533 break;
4534
4535 case SPDIF_CS_SmpFreq_48:
4536 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
4537 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
4538 break;
4539
4540 case SPDIF_CS_SmpFreq_176:
4541 stDigitalChannelStatusTx1.u8SamplingRate = 0x30;
4542 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
4543 break;
4544
4545 case SPDIF_CS_SmpFreq_88:
4546 stDigitalChannelStatusTx1.u8SamplingRate = 0x10;
4547 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
4548 break;
4549
4550 case SPDIF_CS_SmpFreq_44:
4551 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4552 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4553 break;
4554
4555 case SPDIF_CS_SmpFreq_64:
4556 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
4557 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
4558 break;
4559
4560 case SPDIF_CS_SmpFreq_32:
4561 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
4562 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
4563 break;
4564
4565 default:
4566 status_rtn = FALSE;
4567 break;
4568 }
4569 status_rtn = TRUE;
4570 break;
4571
4572 case SPDIF_CS_ClockAcc:
4573 status_rtn = TRUE;
4574 break;
4575
4576 case SPDIF_ChannelAB:
4577 if (status == SPDIF_ChannelAB_Invalid_ON)
4578 {
4579 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx1 Invalid bit=high in non-PCM mode
4580 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx2 Invalid bit=high in non-PCM mode
4581 }
4582 if (status == SPDIF_ChannelAB_Invalid_OFF)
4583 {
4584 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx1 Invalid bit=low in PCM mode
4585 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx2 Invalid bit=low in PCM mode
4586 }
4587 status_rtn = TRUE;
4588 break;
4589
4590 case SPDIF_CS_CopyProtect:
4591 switch (status)
4592 {
4593 case SPDIF_CS_CopyProtect_CopyFree:
4594 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
4595 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4596 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
4597 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4598 status_rtn = TRUE;
4599 break;
4600
4601 case SPDIF_CS_CopyProtect_CopyOnce:
4602 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4603 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
4604 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4605 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
4606 status_rtn = TRUE;
4607 break;
4608
4609 case SPDIF_CS_CopyProtect_CopyNever:
4610 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
4611 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
4612 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
4613 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
4614 status_rtn = TRUE;
4615 break;
4616
4617 default:
4618 status_rtn = FALSE;
4619 break;
4620 }
4621 break;
4622
4623 default:
4624 status_rtn = FALSE;
4625 break;
4626
4627 }
4628
4629 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
4630 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
4631
4632 return(status_rtn);
4633 }
4634
4635 ////////////////////////////////////////////////////////////////////////////////
4636 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_Monitor_SamplingRate()
4637 /// @brief \b Function \b Description: This routine is to set ADC clock for SPDIF raw out
4638 /// @param <IN> \b NONE :
4639 /// @param <OUT> \b NONE :
4640 /// @param <RET> \b NONE :
4641 /// @param <GLOBAL> \b NONE :
4642 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)4643 void HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)
4644 {
4645 return;
4646 }
4647
4648 ////////////////////////////////////////////////////////////////////////////////
4649 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetOutputType()
4650 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4651 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource,AUDIO_SPDIF_OUTPUT_TYPE eType)4652 void HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource, AUDIO_SPDIF_OUTPUT_TYPE eType)
4653 {
4654 eSource=eSource;
4655 eType=eType;
4656 }
4657
4658 ///-----------------------------------------------------------------------------
4659 ////////////////////////////////////////////////////////////////////////////////
4660 ////////////////////////////////////////////////////////////////////////////////
4661 ///
4662 /// AUDIO HDMI Relational Hal Function
4663 ///
4664 ////////////////////////////////////////////////////////////////////////////////
4665 ////////////////////////////////////////////////////////////////////////////////
4666 ///-----------------------------------------------------------------------------
4667 ////////////////////////////////////////////////////////////////////////////////
4668 /// @brief \b Function \b Name: _HAL_AUDIO_HDMI_Tx_SetMute()
4669 /// @brief \b Function \b Description: This routine is used to mute HDMI Tx output(by DSP)
4670 /// @param <IN> \b bEnMute : 0--Disable mute
4671 /// 1--Enable mute
4672 /// @param <OUT> \b NONE :
4673 /// @param <RET> \b NONE :
4674 /// @param <GLOBAL> \b NONE :
4675 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)4676 void _HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)
4677 {
4678 return;
4679 }
4680
4681 ////////////////////////////////////////////////////////////////////////////////
4682 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor()
4683 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status
4684 /// @param <IN> \b NONE :
4685 /// @param <OUT> \b NONE :
4686 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4687 /// @param <GLOBAL> \b NONE :
4688 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor(void)4689 MS_BOOL HAL_AUDIO_HDMI_NonpcmMonitor(void)
4690 {
4691 HAL_AUDIO_AbsWriteMaskByte(0x1027C8, 0x02, 0x02); // Add audio bank offset
4692 if(((HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_INPUT) & 0xC0)==0x40)||(HAL_AUDIO_HDMI_NonpcmMonitor2() == 0x1))
4693 {
4694 return (TRUE);
4695 }
4696 else
4697 {
4698 return (FALSE);
4699 }
4700 }
4701
4702 ////////////////////////////////////////////////////////////////////////////////
4703 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor2()
4704 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status from DSP
4705 /// @param <IN> \b NONE :
4706 /// @param <OUT> \b NONE :
4707 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
4708 /// @param <GLOBAL> \b NONE :
4709 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor2(void)4710 MS_U8 HAL_AUDIO_HDMI_NonpcmMonitor2(void)
4711 {
4712 MS_U32 HDMI_lock_status_tmp;
4713 HDMI_lock_status_tmp = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_hdmi_npcm_lock, DSP_MEM_TYPE_DM);
4714 if ((HDMI_lock_status_tmp&0x30) == 0x30)
4715 {
4716 return (1);
4717 }
4718 else
4719 {
4720 return (0);
4721 }
4722 }
4723
4724 ////////////////////////////////////////////////////////////////////////////////
4725 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_DolbyMonitor() @@Need_Modify
4726 /// @brief \b Function \b Description: Report HDMI non-PCM Dolby mod status
4727 /// @param <IN> \b NONE :
4728 /// @param <OUT> \b NONE :
4729 /// @param <RET> \b u8DolbyModeType :
4730 /// 0-- Other mode
4731 /// 1-- Dolby mode
4732 /// @param <GLOBAL> \b NONE :
4733 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_DolbyMonitor(void)4734 MS_U8 HAL_AUDIO_HDMI_DolbyMonitor(void)
4735 {
4736 return HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_HDMI_PC);
4737 }
4738
4739 ////////////////////////////////////////////////////////////////////////////////
4740 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_SetNonpcm() @@Need_Modify
4741 /// @brief \b Function \b Description: Set HDMI PCM/non-PCM Mode
4742 /// @param <IN> \b nonPCM_en :
4743 /// -- 0: PCM mode
4744 /// -- 1: non-PCM mode
4745 /// @param <OUT> \b NONE :
4746 /// @param <RET> \b NONE :
4747 /// @param <GLOBAL> \b NONE :
4748 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)4749 void HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)
4750 {
4751 //=======================================================
4752 Hdmi_Input_Path HDMI_INPUT_PATH ;
4753 MS_BOOL bIsNonPCM= FALSE;
4754 MS_U8 u8DecoderType = 0;
4755
4756 bIsNonPCM = (MS_BOOL)(nonPCM_en & HDMI_NonPCM_Mask); // Use bit 1 mask check PCM/nonPCM
4757 HDMI_INPUT_PATH = (Hdmi_Input_Path)(nonPCM_en & HDMI_Input_Path_Mask); // Use bit2 mask check main or sub in PIP
4758
4759 if (bIsNonPCM) //====== HDMI nonpcm mode =======
4760 {
4761 u8DecoderType = HAL_AUDIO_HDMI_DolbyMonitor();
4762
4763 switch(u8DecoderType)
4764 {
4765 case AU_HDMI_DTS_TYPE1:
4766 case AU_HDMI_DTS_TYPE2:
4767 case AU_HDMI_DTS_TYPE3:
4768 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4769 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_DTS);
4770 else
4771 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_DTS);
4772
4773 break;
4774 case AU_HDMI_AC3:
4775 case AU_HDMI_AC3P:
4776 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4777 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_AC3);
4778 else
4779 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_AC3);
4780
4781 break;
4782 };
4783
4784 // Audio Input path config
4785 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
4786 {
4787 // HDMI in 2nd Decoder
4788 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4789 {
4790 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_6);
4791 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
4792 }
4793 else
4794 {
4795 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_MAIN);
4796 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
4797 }
4798 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP); // Stop
4799 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG,0x07,0x04);
4800 MsOS_DelayTask(10);
4801 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_PLAY); // PlaY
4802 }
4803 else // HDMI in 1st Decoder
4804 {
4805 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4806 {
4807 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_6);
4808 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
4809 }
4810 else
4811 {
4812 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_MAIN);
4813 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
4814 }
4815
4816 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP); // Stop
4817 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04);
4818 MsOS_DelayTask(10);
4819 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_PLAY); // Play
4820 }
4821
4822 //========= Set for S/PDIF out ===========
4823 HAL_AUDIO_SPDIF_SetMode(_HAL_AUDIO_SPDIF_GetMode(), E_AUDIO_INFO_HDMI_IN);
4824
4825 //Byte swap setting
4826 if (HAL_AUDIO_HDMI_DolbyMonitor() == AU_HDMI_AC3P)
4827 {
4828 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 1, 0);
4829 }
4830 else
4831 {
4832 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 0, 0);
4833 }
4834 }
4835 else //====== HDMI pcm mode =======
4836 {
4837 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
4838 {
4839 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_6);
4840 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x19);
4841 }
4842 else
4843 {
4844 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_MAIN);
4845 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x19);
4846 }
4847
4848 HAL_AUDIO_SPDIF_SetMode(SPDIF_OUT_PCM, E_AUDIO_INFO_HDMI_IN);
4849 }
4850
4851 }
4852
4853 ////////////////////////////////////////////////////////////////////////////////
4854 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_AC3_PathCFG() @@Need_Modify
4855 /// @brief \b Function \b Description: Set DVB/HDMI AC3 path Control
4856 /// @param <IN> \b u8Ctrl :
4857 /// -- 0: DVB2_AD path
4858 /// -- 1: HDMI path
4859 /// @param <OUT> \b NONE :
4860 /// @param <RET> \b NONE :
4861 /// @param <GLOBAL> \b NONE :
4862 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)4863 void HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)
4864 {
4865 if (u8Ctrl == 1)
4866 { // HDMI
4867 /* use CH1 decode HDMI AC3 */
4868 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04); // HDMI_AC3 REG CFG
4869 }
4870 else
4871 { // DTV
4872 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x00); // DVB1 REG CFG
4873 }
4874 }
4875
4876
4877 ////////////////////////////////////////////////////////////////////////////////
4878 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Get_SYNTH_FREQ() @@Need_Modify
4879 /// @brief \b Function \b Description: Audio HDMI CTS-N synthesizer input signal detect.
4880 /// @param <IN> \b NONE :
4881 /// @param <OUT> \b MS_U16 : return freq. If no signal, return 0
4882 /// @param <RET> \b NONE :
4883 /// @param <GLOBAL> \b NONE :
4884 ////////////////////////////////////////////////////////////////////////////////
4885
HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)4886 MS_U16 HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)
4887 {
4888 MS_U16 freq;
4889
4890 freq = HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH) + 0x100 * HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH+1);
4891
4892 if(freq & 0x8000)
4893 return 0; //no signal
4894
4895 return freq;
4896 }
4897
4898 ////////////////////////////////////////////////////////////////////////////////
4899 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Set_DwonSample() @@Cathy
4900 /// @brief \b Function \b Description: set HDMI downsample rate
4901 /// @param <IN> \b MS_U8 : donwsample ratio ; no need in T3
4902 /// @param <OUT> \b NONE :
4903 /// @param <RET> \b NONE :
4904 /// @param <GLOBAL> \b NONE :
4905 ////////////////////////////////////////////////////////////////////////////////
4906
HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)4907 void HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)
4908 {
4909 ratio=ratio; // No need in T3
4910 }
4911
4912
4913 ////////////////////////////////////////////////////////////////////////////////
4914 /// @brief \b Function \b Name: HAL_AUDIO_HDMIAutoMute() @@Need_Modify
4915 /// @brief \b Function \b This routine sets the automute function of HDMI.
4916 /// @param <IN> \b MS_U8 : ch : 0~5
4917 /// value: register value
4918 /// @param <OUT> \b NONE :
4919 /// @param <RET> \b NONE :
4920 /// @param <GLOBAL> \b NONE :
4921 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMIAutoMute(MS_U8 ch,MS_U8 value)4922 void HAL_AUDIO_HDMIAutoMute(MS_U8 ch, MS_U8 value)
4923 {
4924 if(ch < 4)
4925 {
4926 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+(ch<<1),value);
4927 }
4928 else if(ch == 4)
4929 {
4930 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+1,value);
4931 }
4932 else if(ch == 5)
4933 {
4934 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL2+1,value);
4935 }
4936 }
4937
4938 ////////////////////////////////////////////////////////////////////////////////
4939 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Tx_GetStatus()
4940 /// @brief \b Function \b Description: This routine is used to get HDMI Tx status
4941 /// @param onOff \b : HDMI tx function is availible in this chip ?
4942 /// @param hdmi_SmpFreq \b : Audio current sample freq for tx
4943 /// @param outType \b : PCM mode or nonPCM mode
4944 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL * onOff,AUDIO_FS_TYPE * hdmi_SmpFreq,HDMI_TX_OUTPUT_TYPE * outType)4945 void HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL *onOff, AUDIO_FS_TYPE *hdmi_SmpFreq, HDMI_TX_OUTPUT_TYPE *outType )
4946 {
4947 *onOff = FALSE;
4948 *hdmi_SmpFreq = AUDIO_FS_UNSUPPORT;
4949 *outType = HDMI_OUT_PCM;
4950 }
4951
4952
4953
4954 ///-----------------------------------------------------------------------------
4955 ////////////////////////////////////////////////////////////////////////////////
4956 ////////////////////////////////////////////////////////////////////////////////
4957 ///
4958 /// AUDIO Internel Use Hal Function
4959 ///
4960 ////////////////////////////////////////////////////////////////////////////////
4961 ////////////////////////////////////////////////////////////////////////////////
4962 ///-----------------------------------------------------------------------------
4963
4964 ////////////////////////////////////////////////////////////////////////////////
4965 /// @brief \b Function \b Name: _HAL_AUDIO_InitStep1() @@Need_Modify
4966 /// @brief \b Function \b Description: This routine is the initialization for Audio module(Step1).
4967 /// @param <IN> \b NONE :
4968 /// @param <OUT> \b NONE :
4969 /// @param <RET> \b NONE :
4970 /// @param <GLOBAL> \b NONE :
4971 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_InitStep1(void)4972 void _HAL_AUDIO_InitStep1(void)
4973 {
4974 HAL_AUDIO_WriteInitTable();
4975 HAL_AUDIO_SetPowerOn(1);
4976
4977 HAL_AUDIO_SwResetMAD();
4978
4979 // Cathy need remove
4980 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0002);
4981 AUDIO_DELAY1MS(2);
4982 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0003);
4983
4984 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0002);
4985 AUDIO_DELAY1MS(2);
4986 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0003);
4987 // Reset Audio MIU Request for DEC-DSP
4988 HAL_MAD_DisEn_MIUREQ();
4989
4990 }
4991
4992
4993 ////////////////////////////////////////////////////////////////////////////////
4994 /// @brief \b Function \b Name: HAL_AUDIO_SetDspBaseAddr()
4995 /// @brief \b Function \b Description: This function is used to set bin file base address in flash for Audio module.
4996 /// @param <IN> \b u8Index :
4997 /// @param <IN> \b Bin_Base_Address :
4998 /// @param <IN> \b Mad_Base_Buffer_Adr :
4999 /// @param <OUT> \b NONE :
5000 /// @param <RET> \b NONE :
5001 /// @param <GLOBAL> \b NONE :
5002 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index,MS_PHY phyBin_Base_Address,MS_PHY phyMad_Base_Buffer_Adr)5003 void HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index, MS_PHY phyBin_Base_Address, MS_PHY phyMad_Base_Buffer_Adr)
5004 {
5005 HALAUDIO_CHECK_SHM_INIT;
5006
5007 g_AudioVars2->g_DSPMadMIUBank[u8Index] = (MS_U8) (phyMad_Base_Buffer_Adr & 0x0000000F);
5008 phyMad_Base_Buffer_Adr &= 0xFFFFFFF0;
5009 switch(u8Index)
5010 {
5011 case(DSP_ADV): //DSP_ADV=R2=2
5012 #if 1 //jway...patch
5013 HALAUDIO_PRINT("Jway..test\n");
5014 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = 0x00000000; //R2 ADDR setting
5015 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = 0x3D800000;
5016 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5017 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5018 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5019
5020 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = 0x00000000; //SE ADEC ADDR setting
5021 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = 0x3D800000 + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
5022 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5023 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
5024 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
5025
5026 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = 0x00000000; //Comm ADDR setting
5027 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
5028 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5029 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
5030 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
5031 #else
5032 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = phyBin_Base_Address; //R2 ADDR setting
5033 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = phyMad_Base_Buffer_Adr;
5034 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5035 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5036 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5037
5038 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = phyBin_Base_Address; //SE ADEC ADDR setting
5039 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = phyMad_Base_Buffer_Adr + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
5040 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5041 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
5042 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
5043
5044 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = phyBin_Base_Address; //Comm ADDR setting
5045 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
5046 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
5047 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
5048 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
5049 #endif
5050 break;
5051 default:
5052 u8Index = u8Index;
5053 break;
5054 }
5055 #ifndef MSOS_TYPE_NUTTX
5056 AUDIO_TEE_INFO_SHM_CHECK_NULL;
5057 REE_TO_TEE_MBX_MSG_SET_PARAM(0, u8Index);
5058 REE_TO_TEE_MBX_MSG_SET_PARAM(1, (MS_U8)(phyBin_Base_Address&0xFF));
5059 REE_TO_TEE_MBX_MSG_SET_PARAM(2, (MS_U8)((phyBin_Base_Address>>8)&0xFF));
5060 REE_TO_TEE_MBX_MSG_SET_PARAM(3, (MS_U8)((phyBin_Base_Address>>16)&0xFF));
5061 REE_TO_TEE_MBX_MSG_SET_PARAM(4, (MS_U8)((phyBin_Base_Address>>24)&0xFF));
5062 REE_TO_TEE_MBX_MSG_SET_PARAM(5, (MS_U8)(phyMad_Base_Buffer_Adr&0xFF));
5063 REE_TO_TEE_MBX_MSG_SET_PARAM(6, (MS_U8)((phyMad_Base_Buffer_Adr>>8)&0xFF));
5064 REE_TO_TEE_MBX_MSG_SET_PARAM(7, (MS_U8)((phyMad_Base_Buffer_Adr>>16)&0xFF));
5065 REE_TO_TEE_MBX_MSG_SET_PARAM(8, (MS_U8)((phyMad_Base_Buffer_Adr>>24)&0xFF));
5066 REE_TO_TEE_MBX_MSG_SET_PARAM_COUNT(9);
5067 HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr | REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
5068 #endif
5069 HALAUDIO_PRINT ("%d DSPBinBaseAddress = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPBinBaseAddress[u8Index]);
5070 HALAUDIO_PRINT ("%d DSPMadBaseBufferAdr = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index]);
5071 HALAUDIO_PRINT ("%d DSPMadMIUBank = %d\n", u8Index, g_AudioVars2->g_DSPMadMIUBank[u8Index]);
5072 }
5073
5074 ////////////////////////////////////////////////////////////////////////////////
5075 /// @brief \b Function \b Name: HAL_AUDIO_GetDspMadBaseAddr()
5076 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5077 /// @param <IN> \b u8Index :
5078 /// @param <OUT> \b NONE :
5079 /// @param <RET> \b MS_U32: return the MAD base address
5080 /// @param <GLOBAL> \b NONE :
5081 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)5082 MS_PHY HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)
5083 {
5084 HALAUDIO_CHECK_SHM_INIT;
5085
5086 if (u8Index == DSP_DEC) // MM case
5087 {
5088 return g_AudioVars2->g_DSPMadBaseBufferAdr[DSP_SE];
5089 }
5090 return g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
5091 }
5092
5093 ////////////////////////////////////////////////////////////////////////////////
5094 /// @brief \b Function \b Name: HAL_AUDIO_GetDspBinBaseAddr()
5095 /// @brief \b Function \b Description: This function is used to get the Bin file base address.
5096 /// @param <IN> \b u8Index :
5097 /// @param <OUT> \b NONE :
5098 /// @param <RET> \b MS_U32: return the Bin file base address
5099 /// @param <GLOBAL> \b NONE :
5100 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)5101 MS_PHY HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)
5102 {
5103 HALAUDIO_CHECK_SHM_INIT;
5104
5105 return g_AudioVars2->g_DSPBinBaseAddress[u8Index];
5106 }
5107
5108 ////////////////////////////////////////////////////////////////////////////////
5109 /// @brief \b Function \b Name: HAL_AUDIO_SetDspCodeType()
5110 /// @brief \b Function \b Description: This function is used to set the DSP code type.
5111 /// @param <IN> \b NONE :
5112 /// @param <OUT> \b NONE :
5113 /// @param <RET> \b MS_U8: DSP code type.
5114 /// @param <GLOBAL> \b NONE :
5115 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5116 void HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5117 {
5118 HALAUDIO_CHECK_SHM_INIT;
5119
5120 if(bFlag == FALSE)
5121 {
5122 DBG_AUDIO_ERROR(" [Audio] DSP1 Load code fail !!! SetDspCodeType Fail !!! \r\n");
5123 return;
5124 }
5125
5126 g_AudioVars2->g_DspCodeType = dspCodeType;
5127 }
5128
5129 ////////////////////////////////////////////////////////////////////////////////
5130 /// @brief \b Function \b Name: HAL_AUDIO_GetDspCodeType()
5131 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5132 /// @param <IN> \b NONE :
5133 /// @param <OUT> \b NONE :
5134 /// @param <RET> \b MS_U8: DSP code type.
5135 /// @param <GLOBAL> \b NONE :
5136 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspCodeType(void)5137 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDspCodeType(void)
5138 {
5139 HALAUDIO_CHECK_SHM_INIT;
5140
5141 return g_AudioVars2->g_DspCodeType;
5142 }
5143
5144
5145 ////////////////////////////////////////////////////////////////////////////////
5146 /// @brief \b Function \b Name: HAL_AUDIO_SetDsp2CodeType() @@Cathy
5147 /// @brief \b Function \b Description: This function is used to set the DSP2 code type.
5148 /// @param <IN> \b NONE :
5149 /// @param <OUT> \b NONE :
5150 /// @param <RET> \b MS_U8: DSP code type.
5151 /// @param <GLOBAL> \b NONE :
5152 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5153 void HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5154 {
5155 HALAUDIO_CHECK_SHM_INIT;
5156
5157 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5158 {
5159 return;
5160 }
5161
5162 if(bFlag == FALSE)
5163 {
5164 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " [Audio] DSP2 Load code fail !!! SetDsp2CodeType Fail !!! \r\n");
5165 return;
5166 }
5167 g_AudioVars2->g_Dsp2CodeType = dspCodeType;
5168 }
5169
5170 ////////////////////////////////////////////////////////////////////////////////
5171 /// @brief \b Function \b Name: HAL_AUDIO_GetDsp2CodeType() @@Cathy
5172 /// @brief \b Function \b Description: This function is used to get the MAD base address.
5173 /// @param <IN> \b NONE :
5174 /// @param <OUT> \b NONE :
5175 /// @param <RET> \b MS_U8: DSP code type.
5176 /// @param <GLOBAL> \b NONE :
5177 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDsp2CodeType(void)5178 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDsp2CodeType(void)
5179 {
5180 HALAUDIO_CHECK_SHM_INIT;
5181
5182 return g_AudioVars2->g_Dsp2CodeType;
5183 }
5184
5185 ////////////////////////////////////////////////////////////////////////////////
5186 /// @brief \b Function \b Name: HAL_AUDIO_GetDSPalive()
5187 /// @brief \b Function \b Description: This function is used to check if DSP alive.
5188 /// @param <IN> \b NONE :
5189 /// @param <OUT> \b NONE :
5190 /// @param <RET> \b MS_U8: DSP alive status.
5191 /// @param <GLOBAL> \b NONE :
5192 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDSPalive(void)5193 MS_U8 HAL_AUDIO_GetDSPalive(void)
5194 {
5195 HALAUDIO_CHECK_SHM_INIT;
5196
5197 return g_AudioVars2->g_u8DspAliveFlag;
5198 }
5199
5200 ////////////////////////////////////////////////////////////////////////////////
5201 /// @brief \b Function \b Name: HAL_AUDIO_SetDSPalive()
5202 /// @brief \b Function \b Description: This function is used to set flag after DSP alive.
5203 /// @param <IN> \b NONE :
5204 /// @param <OUT> \b NONE :
5205 /// @param <RET> \b NONE :
5206 /// @param <GLOBAL> \b NONE :
5207 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDSPalive(MS_U8 alive)5208 void HAL_AUDIO_SetDSPalive(MS_U8 alive)
5209 {
5210 HALAUDIO_CHECK_SHM_INIT;
5211
5212 g_AudioVars2->g_u8DspAliveFlag = alive;
5213 }
5214
5215 ////////////////////////////////////////////////////////////////////////////////
5216 /// @brief \b Function \b Name: HAL_AUDIO_SetAdvSndEffDspCodeType() @@Cathy
5217 /// @brief \b Function \b Description: This function is used to set the DSP AdvSndEff code type.
5218 /// @param <IN> \b NONE :
5219 /// @param <OUT> \b NONE :
5220 /// @param <RET> \b MS_U8: DSP code type.
5221 /// @param <GLOBAL> \b NONE :
5222 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)5223 void HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
5224 {
5225 HALAUDIO_CHECK_SHM_INIT;
5226
5227 if (bFlag == FALSE)
5228 {
5229 DBG_AUDIO_ERROR(" [Audio] ADV_DSP Load code fail !!! SetAdvSndEffDspCodeType Fail !!! \r\n");
5230 return;
5231 }
5232
5233 g_AudioVars2->g_AdvSndEffDspCodeType = dspCodeType;
5234 }
5235
5236 ////////////////////////////////////////////////////////////////////////////////
5237 /// @brief \b Function \b Name: HAL_AUDIO_GetAdvSndEffDspCodeType() @@Cathy
5238 /// @brief \b Function \b Description: This function is used to get the DSP AdvSndEff code type.
5239 /// @param <IN> \b NONE :
5240 /// @param <OUT> \b NONE :
5241 /// @param <RET> \b MS_U8: DSP code type.
5242 /// @param <GLOBAL> \b NONE :
5243 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetAdvSndEffDspCodeType(void)5244 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetAdvSndEffDspCodeType(void)
5245 {
5246 HALAUDIO_CHECK_SHM_INIT;
5247
5248 return g_AudioVars2->g_AdvSndEffDspCodeType;
5249 }
5250
5251 ////////////////////////////////////////////////////////////////////////////////
5252 /// @brief \b Function \b Name: HAL_AUDIO_BackupMailbox() @@Need_Modify
5253 /// @brief \b Function \b Description: This function is used to backup SIF mailbox.
5254 /// @param <IN> \b NONE :
5255 /// @param <OUT> \b NONE :
5256 /// @param <RET> \b NONE :
5257 /// @param <GLOBAL> \b NONE :
5258 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BackupMailbox(void)5259 void HAL_AUDIO_BackupMailbox(void)
5260 {
5261 HAL_SIF_BackupMailbox();
5262 }
5263
5264 ////////////////////////////////////////////////////////////////////////////////
5265 /// @brief \b Function \b Name: HAL_AUDIO_RestoreMailbox() @@Need_Modify
5266 /// @brief \b Function \b Description: This function is used to restore SIF mailbox.
5267 /// @param <IN> \b NONE :
5268 /// @param <OUT> \b NONE :
5269 /// @param <RET> \b NONE :
5270 /// @param <GLOBAL> \b NONE :
5271 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RestoreMailbox(void)5272 void HAL_AUDIO_RestoreMailbox(void)
5273 {
5274 HAL_SIF_RestoreMailbox();
5275 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0xFF); // Toggle 2BCE to update N.F value
5276 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0x00);
5277 }
5278
5279
5280 ////////////////////////////////////////////////////////////////////////////////
5281 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5282 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5283 /// @param <IN> \b eType : sampleRate of PCM
5284 /// @param <OUT> \b NONE :
5285 /// @param <RET> \b NONE :
5286 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)5287 void HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)
5288 {
5289 MS_U32 audio_pcm_dmaRdr_bufSz = HW_DMA_RDR1_BUF_SIZE;
5290 MS_PHY audio_pcm_dmaRdr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
5291 MS_U16 synthrate, divisor;
5292 MS_U8 tmp1, tmp2, tmp3, tmp4;
5293 MS_U32 i;
5294
5295 /* init DMA writer address */
5296 dmaReader_writePtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5297 dmaReader_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
5298 dmaReader_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base + audio_pcm_dmaRdr_bufSz);
5299
5300 /* New DMA Reader setting
5301 * Formula is :
5302 * Synthesizer Rate = 216MHz / Divisor(1, 2, 4 or 8) * 1024 / 256 / Sampling Rate(32Khz, 44.1KHz or 48KHz)
5303 */
5304 switch(sampleRate)
5305 {
5306 case SAMPLE_RATE_96000:
5307 divisor = 0;
5308 synthrate = 0x2328;
5309 break;
5310 case SAMPLE_RATE_44100:
5311 divisor = 0;
5312 synthrate = 0x4C87;
5313 break;
5314 case SAMPLE_RATE_32000:
5315 divisor = 0;
5316 synthrate = 0x6978;
5317 break;
5318 case SAMPLE_RATE_48000:
5319 divisor = 0;
5320 synthrate = 0x4650;
5321 break;
5322 case SAMPLE_RATE_22050:
5323 divisor = 1;
5324 synthrate = 0x4C87;
5325 break;
5326 case SAMPLE_RATE_16000:
5327 divisor = 1;
5328 synthrate = 0x6978;
5329 break;
5330 case SAMPLE_RATE_24000:
5331 divisor = 1;
5332 synthrate = 0x4650;
5333 break;
5334 case SAMPLE_RATE_11025:
5335 divisor = 2;
5336 synthrate = 0x4C87;
5337 break;
5338 case SAMPLE_RATE_8000:
5339 divisor = 2;
5340 synthrate = 0x6978;
5341 break;
5342 case SAMPLE_RATE_12000:
5343 divisor = 2;
5344 synthrate = 0x4650;
5345 break;
5346 default:
5347 divisor = 0;
5348 synthrate = 0x4650;
5349 break;
5350 }
5351
5352 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
5353 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04); //SEL_CLK_DMA_READER
5354 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F ); //CH8 sel to DMA Rdr
5355
5356 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //reset dma reader
5357
5358 HAL_AUDIO_WriteMaskByte(0x2B8E, 0xFF, ((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE) & 0xFF)); //DMA Reader Base Addr[7:0]
5359 HAL_AUDIO_WriteMaskReg(0x2B84, 0xFFFF,(((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>8) & 0xFFFF)); //DMA Reader Base Addr[23:8]
5360 HAL_AUDIO_WriteMaskByte(0x2B8F, 0x0F, (((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>24) & 0x0F)); //DMA Reader Base Addr[27:24]
5361
5362 HAL_AUDIO_WriteMaskReg(0x2B86, 0xFFFF, audio_pcm_dmaRdr_bufSz/BYTES_IN_MIU_LINE); //setting : DMA Reader Size
5363 HAL_AUDIO_WriteMaskReg(0x2B88, 0xFFFF, audio_pcm_dmaRdr_bufSz - 12); //setting : DMA Reader Overrun Thr
5364 HAL_AUDIO_WriteMaskReg(0x2B8A, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
5365
5366 /* synthersizer setting update */ //DMA reader
5367 HAL_AUDIO_WriteMaskByte(0x2CA4, 0x20, 0x20); //enable DMA synthesizer
5368 HAL_AUDIO_WriteMaskReg(0x2CB0, 0x6000, (divisor << 13)); //Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH
5369 HAL_AUDIO_WriteMaskReg(0x2C20, 0xFFFF, synthrate); //DMA synthesizer N.F.
5370
5371 /* Reset and Start DMA Reader */
5372 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x6402);
5373 AUDIO_DELAY1MS(1);
5374 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x2402);
5375
5376 /* Clear DMA Reader buffer */
5377 for ( i = 0; i < (HW_DMA_RDR1_BUF_SIZE/4); i++ )
5378 {
5379 tmp1 = 0;
5380 tmp2 = 0;
5381 tmp3 = 0;
5382 tmp4 = 0;
5383
5384 *dmaReader_writePtr++ = tmp1;
5385 *dmaReader_writePtr++ = tmp2;
5386 *dmaReader_writePtr++ = tmp3;
5387 *dmaReader_writePtr++ = tmp4;
5388 }
5389
5390 /* Reset Write Pointer */
5391 dmaReader_writePtr = dmaReader_bufStartAddress;
5392 }
5393
5394 ////////////////////////////////////////////////////////////////////////////////
5395 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
5396 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
5397 /// @param <IN> \b eType : sampleRate of PCM
5398 /// @param <OUT> \b NONE :
5399 /// @param <RET> \b NONE :
5400 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_AllInput_Init(void)5401 void HAL_AUDIO_DmaReader_AllInput_Init(void)
5402 {
5403 HAL_AUDIO_DmaReader_Init(SAMPLE_RATE_48000);
5404 return;
5405 }
5406
5407 ////////////////////////////////////////////////////////////////////////////////
5408 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_WritePCM()
5409 /// @brief \b Function \b Description: This routine is used to write PCM data into DMA reader Buffer
5410 /// @param <IN> \b eType : buffer bytes
5411 /// @param <OUT> \b NONE : TRUE or FALSE
5412 /// @param <RET> \b NONE :
5413 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_WritePCM(void * buffer,MS_U32 bytes)5414 MS_BOOL HAL_AUDIO_DmaReader_WritePCM(void* buffer, MS_U32 bytes)
5415 {
5416 MS_U8 *bufptr = (MS_U8 *)MS_PA2KSEG1((MS_VIRT)buffer);
5417 MS_U8 tmp1, tmp2, tmp3, tmp4, replay_flag=0;
5418 MS_U32 i, level_cnt;
5419
5420 // Mask LEVEL_CNT_MASK before read
5421 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5422 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5423 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5424
5425 if ( level_cnt <= 6 )
5426 {
5427 if ((HAL_AUDIO_ReadReg(0x2B80) & 0x0001) == 0x0001)
5428 replay_flag = 1;
5429
5430 /* reset dma reader */
5431 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //clear wr cntrs
5432
5433 /* Reset and Start DMA Reader */
5434 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x6402);
5435 AUDIO_DELAY1MS(1);
5436 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x2402);
5437
5438 /* Reset Write Pointer */
5439 dmaReader_writePtr = dmaReader_bufStartAddress;
5440
5441 printf("***** Audio DMAReader Buffer empty !! ***** \r\n");
5442 }
5443
5444 // Mask LEVEL_CNT_MASK before read
5445 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
5446 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
5447 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
5448 if(level_cnt < (HW_DMA_RDR1_BUF_SIZE - bytes*2)/BYTES_IN_MIU_LINE)
5449 {
5450 for ( i = 0; i < (bytes/2); i++ )
5451 {
5452 tmp1 = 0;
5453 tmp2 = *bufptr++;
5454 tmp3 = *bufptr++;
5455 tmp4 = 0;
5456
5457 *dmaReader_writePtr++ = tmp1;
5458 *dmaReader_writePtr++ = tmp2;
5459 *dmaReader_writePtr++ = tmp3;
5460 *dmaReader_writePtr++ = tmp4;
5461
5462 if ( dmaReader_writePtr >= dmaReader_bufEndAddress )
5463 dmaReader_writePtr = dmaReader_bufStartAddress;
5464 }
5465 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, bytes*2/BYTES_IN_MIU_LINE);
5466 AUDIO_DELAY1US(5); // To prevent slow update of level_cnt
5467
5468 if (replay_flag == 1)
5469 {
5470 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
5471 AUDIO_DELAY1MS(1);
5472 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
5473 }
5474 return TRUE;
5475 }
5476 return FALSE;
5477 }
5478
5479 ////////////////////////////////////////////////////////////////////////////////
5480 /// @brief \b Function \b Name: HAL_AUDIO_SetEntertainmentMode()
5481 /// @brief \b Function \b Description: This routine is used to switch the DTV/KTV/GAME mode
5482 /// @param <IN> \b eMode :
5483 /// @param <RET> \b NONE :
5484 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)5485 void HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)
5486 {
5487 switch((int)eMode)
5488 {
5489 case AUDIO_ETMODE_DTV :
5490 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5491 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x00);
5492 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5493 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x00); // ADC0 gain 0dB
5494 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5495 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5496 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5497 break;
5498
5499 case AUDIO_ETMODE_KTV :
5500 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5501 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5502 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x80); // enable KTV function
5503 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x80); // ADC0 gain 6dB
5504 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5505 HAL_AUDIO_WriteMaskReg(REG_SNDR2_ADVSND_SEL, 0xFF00, 0x1E00); // Switch R2 to KTV mode
5506 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
5507 break;
5508
5509 case AUDIO_ETMODE_KTV2 : // Use I2S input ; not MicroPhone in
5510 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
5511 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
5512 HAL_AUDIO_WriteMaskByte(0x2D47 , 0xF0, 0xA0); // enable KTV mode; Skyworth (stone) model
5513 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5514 HAL_AUDIO_WriteMaskByte(0x2D5D , 0x80, 0x80); // Mute MIC volume (only mix MP3 & PCM DMA data)
5515 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
5516 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5517 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
5518 break;
5519
5520 case AUDIO_ETMODE_GAME :
5521 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
5522 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5523 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5524 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5525 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5526 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
5527 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5528 break;
5529
5530 case AUDIO_ETMODE_VOIP_ON:
5531 //Voip will setup snd system to GAME MODE,
5532 //In GAME MODE, Voip used 0x2D46[7:0] to
5533 //upload Raw_Delay_SE to DRAM.
5534 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0xA1);
5535
5536 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5537 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xE0);
5538 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0xC4);
5539
5540 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5541 AUDIO_DELAY1MS(1);
5542 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5543 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5544
5545 #if 0
5546 //config SRC to 8KHz
5547 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xF0);//0xE0}, // Group A SRC rate
5548 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x03);//0x07},
5549 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0xF0);//0x50},
5550 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0xD2);//0x46},
5551 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5552 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x04);//0x08},
5553 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0xF0);//0x50},
5554 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0xD2);//0x46},
5555 //update SYNTH
5556 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5557 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5558 AUDIO_DELAY1MS(1);
5559 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5560 //reset GroupA SRC
5561 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5562 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5563 AUDIO_DELAY1MS(1);
5564 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5565 #endif
5566
5567 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_ON\r\n");
5568 break;
5569
5570 case AUDIO_ETMODE_VOIP_OFF:
5571 //disable upload Raw_Delay_SE to DRAM.
5572 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0x00);
5573
5574 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
5575 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xD0);
5576 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0x20);
5577
5578 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
5579 AUDIO_DELAY1MS(1);
5580 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
5581 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
5582
5583 #if 0
5584 //set SRC back to 48KHz
5585 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xE0); // Group A SRC rate
5586 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x07);
5587 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0x50);
5588 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0x46);
5589 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
5590 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x08);
5591 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0x50);
5592 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0x46);
5593 //update SYNTH
5594 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5595 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
5596 AUDIO_DELAY1MS(1);
5597 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
5598 //reset GroupA SRC
5599 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5600 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
5601 AUDIO_DELAY1MS(1);
5602 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
5603 #endif
5604 printf("HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_OFF\r\n");
5605 break;
5606
5607 default :
5608 break;
5609 }
5610 }
5611
5612
5613 ////////////////////////////////////////////////////////////////////////////////
5614 /// @brief \b Function \b Name: HAL_AUDIO_SetSystem()
5615 /// @brief \b Function \b Description: This function will load
5616 /// different audio decoder to audio system.
5617 ///
5618 /// In Mstar audio system, we can support 1 or 2 decoders.
5619 /// One is for main DTV audio or Multimedia audio player.
5620 /// Another is for second audio decode (ex: used for Audio Description purpose)
5621 ///
5622 /// @param enDecSystem \b : (En_DVB_decSystemType) decoder type
5623 /// - parameter type "MSAPI_AUD_DVB_XXXX" is decoder type for main audio decoder
5624 /// - parameter type "MSAPI_AUD_DVB2_XXXX" is decoder type for second audio decoder
5625 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)5626 MS_BOOL HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)
5627 {
5628 MS_BOOL bRet = FALSE;
5629
5630 HAL_AUDIO_SetIsDtvFlag(TRUE);
5631 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, FALSE, 0);
5632
5633 // set decoder system
5634 switch (enDecSystem)
5635 {
5636 ////////////////////////////////////////////////
5637 // Audio Decoder 1
5638 ////////////////////////////////////////////////
5639 case MSAPI_AUD_DVB_MPEG:
5640 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5641 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
5642 break;
5643
5644 case MSAPI_AUD_DVB_AC3:
5645 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5646 AUDIO_DELAY1MS(1);
5647 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5648 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5649 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3, TRUE);
5650 break;
5651
5652 case MSAPI_AUD_DVB_AC3P:
5653 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5654 AUDIO_DELAY1MS(1);
5655 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5656 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5657 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
5658 break;
5659
5660 case MSAPI_AUD_DVB_MP3:
5661 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
5662 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MP3, TRUE);
5663 break;
5664
5665 case MSAPI_AUD_DVB_AAC:
5666 case MSAPI_AUD_DVB_MS10_DDT:
5667 if (g_AudioVars2->DolbyAACFlag == 1)
5668 {
5669 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_aac);
5670 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
5671 }
5672 else
5673 {
5674 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_gaac);
5675 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
5676 }
5677 break;
5678
5679 case MSAPI_AUD_DVB_XPCM:
5680 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_xpcm);
5681 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
5682 break;
5683
5684 case MSAPI_AUD_DVB_RA8LBR:
5685 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ra8);
5686 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
5687 break;
5688
5689 case MSAPI_AUD_DVB_WMA:
5690 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5691 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
5692 break;
5693
5694 case MSAPI_AUD_DVB_DTS:
5695 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
5696 AUDIO_DELAY1MS(1);
5697 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
5698 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
5699 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5700 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
5701 break;
5702
5703 case MSAPI_AUD_DVB_DTSLBR:
5704 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
5705 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTSLBR, TRUE);
5706 break;
5707
5708 case MSAPI_AUD_DVB_MS10_DDC:
5709 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
5710 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDC, TRUE);
5711 break;
5712
5713 case MSAPI_AUD_DVB_WMA_PRO:
5714 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
5715 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
5716 break;
5717
5718 case MSAPI_AUD_DVB_FLAC:
5719 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_flac);
5720 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
5721 break;
5722
5723 case MSAPI_AUD_DVB_VORBIS:
5724 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_vorbis);
5725 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
5726 break;
5727
5728 case MSAPI_AUD_DVB_AMR_NB:
5729 break;
5730
5731 case MSAPI_AUD_DVB_AMR_WB:
5732 break;
5733
5734 case MSAPI_AUD_DVB_DRA:
5735 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dra);
5736 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
5737 break;
5738
5739
5740 ////////////////////////////////////////////////
5741 // Audio Decoder 2
5742 ////////////////////////////////////////////////
5743 case MSAPI_AUD_DVB2_MPEG:
5744 case MSAPI_AUD_DVB2_MP3:
5745 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
5746 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MP3, TRUE);
5747 break;
5748
5749 case MSAPI_AUD_DVB2_AC3:
5750 case MSAPI_AUD_DVB2_AC3P:
5751 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
5752 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3, TRUE);
5753 break;
5754
5755 case MSAPI_AUD_DVB2_AAC:
5756 case MSAPI_AUD_DVB2_GAAC:
5757 if (g_AudioVars2->DolbyAACFlag == 1)
5758 {
5759 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_aac);
5760 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
5761 }
5762 else
5763 {
5764 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_gaac);
5765 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
5766 }
5767 break;
5768
5769 case MSAPI_AUD_DVB2_DTS:
5770 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dts);
5771 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
5772 break;
5773
5774 case MSAPI_AUD_DVB2_XPCM:
5775 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_xpcm);
5776 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
5777 break;
5778
5779 default:
5780 HAL_AUDIO_SetIsDtvFlag(FALSE);
5781 bRet = TRUE;
5782 break;
5783 }
5784 return bRet;
5785 }
5786
5787 ////////////////////////////////////////////////////////////////////////////////
5788 /// @brief \b Function \b Name: HAL_AUDIO_GetDecSysSupportStatus()
5789 /// @brief \b Function \b Description: This function will report Audio Decoder support feature status when giving DecSystem type
5790 /// @param <IN> \b enDecSystem : Decoder type
5791 /// @param <RET> \b BOOL : True or False
5792 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)5793 MS_BOOL HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)
5794 {
5795 MS_BOOL SetDecSys_RtnStatus = FALSE;
5796 switch (enDecSystem)
5797 {
5798 ////////////////////////////////////////////////
5799 // Audio Decoder 1
5800 ////////////////////////////////////////////////
5801 case MSAPI_AUD_DVB_MPEG:
5802 case MSAPI_AUD_DVB_AC3:
5803 case MSAPI_AUD_DVB_AC3P:
5804 case MSAPI_AUD_DVB_MP3:
5805 case MSAPI_AUD_DVB_AAC:
5806 SetDecSys_RtnStatus = TRUE;
5807 break;
5808
5809 case MSAPI_AUD_DVB_MS10_DDT:
5810 case MSAPI_AUD_DVB_MS10_DDC:
5811 SetDecSys_RtnStatus = TRUE;
5812 break;
5813
5814 case MSAPI_AUD_DVB_XPCM:
5815 case MSAPI_AUD_DVB_RA8LBR:
5816 SetDecSys_RtnStatus = TRUE;
5817 break;
5818
5819 case MSAPI_AUD_DVB_WMA:
5820 case MSAPI_AUD_DVB_WMA_PRO:
5821 SetDecSys_RtnStatus = TRUE;
5822 break;
5823
5824 case MSAPI_AUD_DVB_DTS:
5825 SetDecSys_RtnStatus = TRUE;
5826 break;
5827
5828 case MSAPI_AUD_DVB_FLAC:
5829 SetDecSys_RtnStatus = TRUE;
5830 break;
5831
5832 case MSAPI_AUD_DVB_VORBIS:
5833 SetDecSys_RtnStatus = TRUE;
5834 break;
5835
5836 case MSAPI_AUD_DVB_AMR_NB:
5837 SetDecSys_RtnStatus = FALSE;
5838 break;
5839
5840 case MSAPI_AUD_DVB_AMR_WB:
5841 SetDecSys_RtnStatus = FALSE;
5842 break;
5843
5844 ////////////////////////////////////////////////
5845 // Audio Decoder 2
5846 ////////////////////////////////////////////////
5847 case MSAPI_AUD_DVB2_MPEG:
5848 case MSAPI_AUD_DVB2_MP3:
5849 SetDecSys_RtnStatus = TRUE;
5850 break;
5851
5852 case MSAPI_AUD_DVB2_AC3:
5853 case MSAPI_AUD_DVB2_AC3P:
5854 SetDecSys_RtnStatus = TRUE;
5855 break;
5856
5857 case MSAPI_AUD_DVB2_AAC:
5858 SetDecSys_RtnStatus = TRUE;
5859 break;
5860
5861 case MSAPI_AUD_DVB2_DDE:
5862 SetDecSys_RtnStatus = FALSE;
5863 break;
5864
5865 case MSAPI_AUD_DVB2_DTSE:
5866 SetDecSys_RtnStatus = FALSE;
5867 break;
5868
5869 case MSAPI_AUD_DVB2_XPCM:
5870 SetDecSys_RtnStatus = TRUE;
5871 break;
5872
5873 case MSAPI_AUD_DVB2_KTV:
5874 SetDecSys_RtnStatus = TRUE;
5875 break;
5876
5877 case MSAPI_AUD_DVB_TONE:
5878 case MSAPI_AUD_DVB_NONE:
5879 case MSAPI_AUD_DVB2_NONE:
5880 default:
5881 SetDecSys_RtnStatus = FALSE;
5882 break;
5883 }
5884 return(SetDecSys_RtnStatus);
5885 }
5886
5887 ////////////////////////////////////////////////////////////////////////////////
5888 /// @brief \b Function \b Name: HAL_AUDIO_AlgReloadCode()
5889 /// @brief \b Function \b Description: This routine is used to reload DSP code
5890 /// @param u8Type \b :
5891 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
5892 /// FALSE--DEC-DSP reload code fail
5893 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AlgReloadCode(MS_U8 u8Type)5894 MS_BOOL HAL_AUDIO_AlgReloadCode(MS_U8 u8Type)
5895 {
5896 // No DEC-DSP in Monaco
5897 return TRUE;
5898 }
5899
5900 ////////////////////////////////////////////////////////////////////////////////
5901 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Check()
5902 /// @brief \b Function \b Description: Check if ALSA Interface is supported
5903 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
5904 /// @param <OUT> \b MS_BOOL : return TRUE if it's supported, else return FALSE
5905 /// @param <RET> \b NONE :
5906 /// @param <GLOBAL> \b NONE :
5907 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Check(void)5908 MS_BOOL HAL_AUDIO_ALSA_Check(void)
5909 {
5910 return TRUE;
5911 }
5912
5913 ////////////////////////////////////////////////////////////////////////////////
5914 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Enable()
5915 /// @brief \b Function \b Description: Enable/ Disable the path of ALSA
5916 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
5917 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
5918 /// @param <RET> \b NONE :
5919 /// @param <GLOBAL> \b NONE :
5920 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)5921 MS_BOOL HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)
5922 {
5923 if (bEnable == TRUE)
5924 {
5925 /* Set as GAME mode */
5926 HAL_AUDIO_SetInputPath(AUDIO_DSP3_DVB_INPUT , AUDIO_PATH_5);
5927 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
5928 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
5929 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
5930 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
5931
5932 return TRUE;
5933 }
5934 else
5935 {
5936 /* Do nothing for the moment */
5937 return FALSE;
5938 }
5939 }
5940
5941 ////////////////////////////////////////////////////////////////////////////////
5942 /// @brief \b Function \b Name: HAL_AUDIO_Alg2ReloadCode()
5943 /// @brief \b Function \b Description: This routine is used to reload the algorithm in se-dsp .
5944 /// @param u8Type \b : information of algorithm code
5945 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
5946 /// FALSE--DEC-DSP reload code fail
5947 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)5948 MS_BOOL HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
5949 {
5950 MS_U16 time_out;
5951 MS_BOOL ret_status = FALSE;
5952
5953 HAL_MAD2_SetDspIDMA();
5954 // Enter MCU/DSP hand-shake
5955 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5956 {
5957 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
5958 }
5959 else
5960 {
5961 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG/0x100);
5962 }
5963
5964 // PIO[8] interrupt
5965 HAL_MAD2_TriggerPIO8();
5966
5967 //Wait Dsp Start reload Ack
5968 time_out = 0;
5969 while (time_out++<2000)
5970 {
5971 if(HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
5972 break;
5973 AUDIO_DELAY1MS(1);
5974 }
5975 if (time_out>=2000)
5976 {
5977 DBG_AUDIO_ERROR(" DSP Reload timeOut1: %d\r\n", time_out);
5978 return FALSE;
5979 }
5980
5981 // Change to IDMA Port
5982 HAL_MAD2_SetDspIDMA();
5983
5984 // Start to Reload DSP code
5985 ret_status = HAL_AUDSP_DspLoadCode(dspCodeType);
5986 HAL_AUDIO_SetDsp2CodeType(dspCodeType, ret_status);
5987
5988 // Enter MCU/DSP hand-shake
5989 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
5990 {
5991 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_END/0x100);
5992 }
5993 else
5994 {
5995 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END/0x100);
5996 }
5997
5998 HAL_MAD2_TriggerPIO8();
5999
6000 // Wait Dsp End Reload Ack
6001 time_out = 0;
6002 while (time_out++<3000)
6003 {
6004 if (HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
6005 break;
6006 AUDIO_DELAY1MS(1);
6007 }
6008
6009 if (time_out>=3000)
6010 {
6011 DBG_AUDIO_ERROR(" DSP Reload timeOut2: %d\r\n", time_out);
6012 return FALSE;
6013 }
6014
6015 DBG_AUDIO("HAL_AUDIO_SeReloadCode finish\r\n");
6016
6017 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
6018
6019 return TRUE;
6020
6021 }
6022
6023 ////////////////////////////////////////////////////////////////////////////////
6024 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeDoneFlag() @@Cathy
6025 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
6026 /// @param <IN> \b NONE :
6027 /// @param <OUT> \b NONE :
6028 /// @param <RET> \b NONE :
6029 /// @param <GLOBAL> \b NONE :
6030 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeDoneTag(void)6031 MS_U16 HAL_AUDIO_GetUniDecodeDoneTag(void)
6032 {
6033 MS_U16 temp1, temp2, i;
6034
6035 for (i = 0; i < 100; i++)
6036 {
6037 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6038 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
6039
6040 if (temp1 == temp2)
6041 {
6042 return (temp1);
6043 }
6044 }
6045
6046 return 0;
6047 }
6048
6049 ////////////////////////////////////////////////////////////////////////////////
6050 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeFrameCnt()
6051 /// @brief \b Function \b Description: This function is used to get the Decoder decoded frame count
6052 /// @param <IN> \b NONE:
6053 /// @param <OUT> \b NONE:
6054 /// @param <RET> \b NONE:
6055 /// @param <GLOBAL> \b NONE:
6056 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)6057 MS_U16 HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)
6058 {
6059 MS_U16 temp1, temp2, i;
6060 Audio_id r2AudioID = ADEC1;
6061
6062
6063 if (eDSPId == AU_DEC_ID3)
6064 {
6065 r2AudioID = ADEC2;
6066 }
6067
6068 for ( i = 0; i < 100; i++ )
6069 {
6070 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6071 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
6072
6073 if ( temp1 == temp2 )
6074 {
6075 return (temp1);
6076 }
6077 }
6078
6079 return 0;
6080 }
6081
6082 //******************************************************************************
6083 // [Function Name]:
6084 // HAL_AUDIO_PTS_info
6085 // [Description]:
6086 // get PTS and OS time or set to reset these reference
6087 // [Arguments]:
6088 //
6089 //*******************************************************************************
HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info)6090 void HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info )
6091 {
6092 AUDIO_PTS_INFO PTS_info;
6093
6094 memcpy((void *)&PTS_info, (void *)access_PTS_info, sizeof(AUDIO_PTS_INFO));
6095
6096 // printf("HAL_AUDIO_PTS_info((0x%x, %d, %lld))\n",(unsigned int)access_PTS_info,(int)PTS_info.os_Time,PTS_info.curPTS);
6097 if (PTS_info.set2Clr) //setting value
6098 {
6099 curr_OS_Time = PTS_info.os_Time;
6100 curr_PTS = PTS_info.curPTS;
6101 }
6102 else // get PTS information
6103 {
6104 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6105
6106 PTS_info.set2Clr = 0 ;
6107 PTS_info.os_Time = curr_OS_Time;
6108 PTS_info.curPTS = curr_PTS;
6109
6110 memcpy((void *)access_PTS_info, (void *)&PTS_info, sizeof(AUDIO_PTS_INFO));
6111
6112 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6113 }
6114 }
6115
HAL_AUDIO_DmaWriter_Init(void)6116 void HAL_AUDIO_DmaWriter_Init(void)
6117 {
6118 MS_U32 audio_pcm_dmaWtr_bufSz = HW_DMA_WTR1_BUF_SIZE; //must be multiple of DMA_RDR_PCM_BUF_UNIT*2 = 0x2000
6119 MS_PHY audio_pcm_dmaWtr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
6120 ///MS_U16 synthrate, divisor;
6121 //MS_U8 tmp1, tmp2, tmp3, tmp4;
6122 //MS_U32 i;
6123 //MS_U32 loop;
6124
6125 /* init DMA writer address */
6126 dmaWriter_readPtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base);
6127 dmaWriter_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base);
6128 dmaWriter_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base + audio_pcm_dmaWtr_bufSz);
6129 // printf("\n\ndmaReader_writePtr dmaReader_bufStartAddress: %lx\n", audio_pcm_dmaWtr_base);
6130
6131 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
6132 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (audio_pcm_dmaWtr_base/BYTES_IN_MIU_LINE) & 0xFFFF);
6133 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (audio_pcm_dmaWtr_base/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
6134 HAL_AUDIO_AbsWriteReg(NewDMAwriter_DRAM_size, audio_pcm_dmaWtr_bufSz/BYTES_IN_MIU_LINE);
6135 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
6136
6137 /* Reset and Start DMA Writer */
6138 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
6139 AUDIO_DELAY1US(1);
6140 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
6141
6142 /* Reset Write Pointer */
6143 dmaWriter_readPtr = dmaWriter_bufStartAddress;
6144 }
6145
HAL_AUDIO_DmaWriter_Read(void * buffer,MS_U32 bytes)6146 MS_BOOL HAL_AUDIO_DmaWriter_Read(void* buffer, MS_U32 bytes)
6147 {
6148 MS_U8 *bufptr;
6149 MS_U16 DRAM_levelcnt = 0, DRAM_levelcnt1;
6150 MS_U32 DRAM_levelcnt_bytes = 0;
6151 MS_U32 i; //, level_cnt, level_cnt1;
6152
6153 bytes = (bytes/BYTES_IN_MIU_LINE)*BYTES_IN_MIU_LINE;
6154 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
6155 DRAM_levelcnt = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
6156 while (DRAM_levelcnt1 != DRAM_levelcnt)
6157 {
6158 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
6159 DRAM_levelcnt = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
6160 }
6161 if (DRAM_levelcnt < (bytes/BYTES_IN_MIU_LINE))
6162 return FALSE;
6163
6164 bufptr = buffer;
6165 DRAM_levelcnt_bytes = DRAM_levelcnt*BYTES_IN_MIU_LINE;
6166 DRAM_levelcnt_bytes = (DRAM_levelcnt_bytes > bytes) ? bytes : DRAM_levelcnt_bytes;
6167
6168 for (i = 0; i < (DRAM_levelcnt_bytes/4); i++)
6169 {
6170 *bufptr++ = *dmaWriter_readPtr++;
6171 *bufptr++ = *dmaWriter_readPtr++;
6172 *bufptr++ = *dmaWriter_readPtr++;
6173 *bufptr++ = *dmaWriter_readPtr++;
6174
6175 if ( dmaWriter_readPtr >= dmaWriter_bufEndAddress)
6176 dmaWriter_readPtr = dmaWriter_bufStartAddress;
6177 }
6178
6179 //printf("D %x\n", DRAM_levelcnt);
6180 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
6181 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, DRAM_levelcnt_bytes/BYTES_IN_MIU_LINE);
6182 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
6183 bytes -= DRAM_levelcnt_bytes;
6184 return TRUE;
6185 }
6186
6187 ////////////////////////////////////////////////////////////////////////////////
6188 /// @brief \b Function \b Name: HAL_AUDIO_RebootDecDSP()
6189 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RebootDecDSP(void)6190 void HAL_AUDIO_RebootDecDSP(void)
6191 {
6192 AUDIO_DSP_CODE_TYPE DspCodeType;
6193 AUD_ERRMSG("\n*MAD Auto-Recovery DSP1* \n");
6194
6195 HALAUDIO_CHECK_SHM_INIT;
6196
6197 g_AudioVars2->g_u8AudioCrashFlag = TRUE;
6198
6199 DspCodeType = HAL_AUDIO_GetDspCodeType();
6200
6201 //if ((u8DspCodeType & 0xF0) != 0x10)
6202 {
6203 HAL_AUDIO_BackupMailbox();
6204 }
6205 // Reset MAD module
6206 HAL_MAD_RSTMAD_DisEn_MIUREQ();
6207 AUDIO_DELAY1MS(2);
6208
6209 //if((u8DspCodeType & 0xF0) != 0x10 )
6210 {
6211 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, FALSE, 0); // Audio SIF channel enable setting -> disable
6212 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 0, 0);
6213
6214 AUDIO_DELAY1MS(2);
6215 }
6216 AUD_DBGMSG("*** Load code and reset DEC DSP \n");
6217 HAL_MAD_SetMemInfo();
6218 HAL_AUDIO_ResetDSP();
6219 HAL_AUDIO_DecoderLoadCode();
6220
6221 //if((u8DspCodeType & 0xF0) != 0x10 )
6222 {
6223 AUDIO_DELAY1MS(50);
6224 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 1, 0);
6225 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0); // Audio SIF channel enable setting -> enable
6226 HAL_AUDIO_RestoreMailbox();
6227 }
6228 }
6229
6230 ////////////////////////////////////////////////////////////////////////////////
6231 /// @brief \b Function \b Name: HAL_AUDIO_DspReboot()
6232 /// @brief \b Function \b Description: This routine is used to do dsp reboot and some specific setting
6233 /// @param <IN> \b eType : param
6234 /// @param <RET> \b NONE :
6235 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspReboot(MS_U8 alive)6236 void HAL_AUDIO_DspReboot(MS_U8 alive)
6237 {
6238 alive = alive;
6239 }
6240
6241
6242 ////////////////////////////////////////////////////////////////////////////////
6243 /// @brief \b Function \b Name: HAL_AUDIO_ReadDspCounter()
6244 /// @brief \b Function \b Description: Read the DSP running counter
6245 /// @param CounterType \b :
6246 /// - DSP_DEC_MAIN_COUNTER ==> Decoder DSP Main loop counter
6247 /// - DSP_DEC_TIMER_COUNTER ==> Decoder Timer counter
6248 /// - DSP_SE_MAIN_COUNTER ==> SE DSP Main loop counter
6249 /// - DSP_SE_TIMER_COUNTER ==> SE Timer counter
6250 /// - DSP_SE_ISR_COUNTER ==> SE Interrupt ISR counter
6251 /// - DEC_R2_MAIN_COUNTER ==> DEC R2 Main loop counter
6252 /// - DEC_R2_TIMER_COUNTER ==> DEC R2 Timer counter
6253 /// - SND_R2_MAIN_COUNTER ==> SND R2 Main loop counter
6254 /// - SND_R2_TIMER_COUNTER ==> SND R2 Timer counter
6255 /// @return MS_U8 \b : Running counter value
6256 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)6257 MS_U8 HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)
6258 {
6259 MS_U8 u8CounterValue=0;
6260
6261 switch(CounterType)
6262 {
6263 case DSP_DEC_MAIN_COUNTER:
6264 break;
6265
6266 case DSP_DEC_TIMER_COUNTER:
6267 break;
6268
6269 case DSP_SE_MAIN_COUNTER:
6270 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_COUNTER);
6271 break;
6272
6273 case DSP_SE_TIMER_COUNTER:
6274 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_TIMER_COUNTER);
6275 break;
6276
6277 case DSP_SE_ISR_COUNTER:
6278 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_ISR_COUNTER);
6279 break;
6280
6281 case DEC_R2_MAIN_COUNTER:
6282 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_MAIN_COUNTER);
6283 break;
6284
6285 case DEC_R2_TIMER_COUNTER:
6286 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_TIMER_COUNTER);
6287 break;
6288
6289 case SND_R2_MAIN_COUNTER:
6290 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_MAIN_COUNTER);
6291 break;
6292
6293 case SND_R2_TIMER_COUNTER:
6294 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_TIMER_COUNTER);
6295 break;
6296
6297 default:
6298 break;
6299 }
6300 return u8CounterValue;
6301 }
6302
6303
6304 ////////////////////////////////////////////////////////////////////////////////
6305 /// @brief \b Function \b Name: HAL_AuProcessPowerDown_Wait()
6306 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
6307 /// @param bEnable \b : TRUE --Not wait,
6308 /// FALSE--wait
6309 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)6310 void HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)
6311 {
6312 bEnable = bEnable;
6313 }
6314
6315 ////////////////////////////////////////////////////////////////////////////////
6316 /// @brief \b Function \b Name: HAL_AUDIO_SendIntrupt()
6317 /// @brief \b Function \b Description: send a PIO8 interrupt to DSP
6318 /// @param bDspType \b :
6319 /// @param u8Cmd \b :
6320 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)6321 void HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)
6322 {
6323 if (bDspType == DSP_DEC)
6324 {
6325 HAL_MAD_SetPIOCmd(u8Cmd);
6326 HAL_MAD_TriggerPIO8();
6327 }
6328 else
6329 {
6330 HAL_MAD2_SetPIOCmd(u8Cmd);
6331 HAL_MAD2_TriggerPIO8();
6332 }
6333 }
6334
6335 ////////////////////////////////////////////////////////////////////////////////
6336 /// @brief \b Function \b Name: HAL_AUDIO_SeSystemLoadCode()
6337 /// @brief \b Function \b Description: This routine is used to load DSP code for SE-DSP .
6338 /// @return MS_BOOL \b : TRUE --DEC-DSP load code okay,
6339 /// FALSE--DEC-DSP load code fail
6340 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeSystemLoadCode(void)6341 MS_BOOL HAL_AUDIO_SeSystemLoadCode(void)
6342 {
6343 MS_U16 time_out = 0;
6344
6345 HAL_MAD2_SetDspIDMA();
6346
6347 AUD_DBGMSG("MDrv_AUDIO_SeSystemLoadCode() \r\n");
6348
6349 HAL_AUDSP_DspLoadCode(AU_SE_SYSTEM);
6350
6351 //Wait Dsp init finished Ack
6352 #ifndef CONFIG_MBOOT
6353 while(time_out++<100) {
6354 if((HAL_MAD2_GetLoadCodeAck() == 0xE3)&&(HAL_AUDIO_ReadByte(0x2EAE) == 0xE3))
6355 break;
6356 AUDIO_DELAY1MS(2);
6357 }
6358 #endif
6359
6360 if (time_out>=100) {
6361 AUD_ERRMSG("DSP2 Re-Active\n");
6362 }
6363 else {
6364 AUD_DBGMSG("audio DSP_SE LoadCode success..\n");
6365 }
6366
6367 //inform DSP to start to run
6368 HAL_MAD2_SetMcuCmd(0xF3);
6369
6370 return TRUE;
6371 }
6372
6373 ////////////////////////////////////////////////////////////////////////////////
6374 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6375 ////////////////////////////////////////////////////////////////////////////////
6376 ////////////////////////////////////////////////////////////////////////////////
6377 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
6378 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecoderLoadCode(void)6379 MS_BOOL HAL_AUDIO_DecoderLoadCode(void)
6380 {
6381 return TRUE;
6382 }
6383
6384 ////////////////////////////////////////////////////////////////////////////////
6385 /// @brief \b Function \b Name: HAL_AUDIO_init()
6386 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Init(MS_BOOL Initype)6387 MS_BOOL HAL_AUDIO_Init(MS_BOOL Initype)
6388 {
6389 Initype = Initype;
6390 return Initype;
6391 }
6392
6393 ////////////////////////////////////////////////////////////////////////////////
6394 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_TX_SetMode()
6395 /// @brief \b Function \b Description: This routine is used to set HDMI output mode
6396 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType,AUDIO_SOURCE_INFO_TYPE eSource)6397 void HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType, AUDIO_SOURCE_INFO_TYPE eSource)
6398 {
6399 outType = outType;
6400 eSource = eSource;
6401 }
6402
6403 ////////////////////////////////////////////////////////////////////////////////
6404 /// @brief \b Function \b Name: HAL_AUDIO_PCMCaptureInit()
6405 /// @brief \b Function \b Description: Select source for pcm capture
6406 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6407 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6408 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6409 /// @param <RET> \b NONE :
6410 /// @param <GLOBAL> \b NONE :
6411 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID,const AUDIO_CAPTURE_SOURCE_TYPE eSource)6412 MS_BOOL HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID, const AUDIO_CAPTURE_SOURCE_TYPE eSource)
6413 {
6414 MS_BOOL ret = TRUE;
6415
6416 switch(eID)
6417 {
6418 case E_DEVICE0:
6419 g_pcm_capture_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
6420 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6421 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6422 break;
6423
6424 case E_DEVICE1:
6425 g_pcm_capture2_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
6426 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
6427 ret = HAL_AUDIO_PCMCapture_Stop(eID);
6428 break;
6429
6430 default:
6431 printf("\r\n =====PCMCapture_Init : unsupported DEVICE TYPE!!!=======");
6432 ret = FALSE;
6433 break;
6434 }
6435
6436 return ret;
6437 }
6438
6439 ////////////////////////////////////////////////////////////////////////////////
6440 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Start()
6441 /// @brief \b Function \b Description: captrue pcm data to DDR
6442 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6443 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6444 /// @param <RET> \b NONE :
6445 /// @param <GLOBAL> \b NONE :
6446 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)6447 MS_BOOL HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)
6448 {
6449 MS_BOOL ret = TRUE;
6450
6451 switch(eID)
6452 {
6453 case E_DEVICE0:
6454 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); // start
6455 break;
6456
6457 case E_DEVICE1:
6458 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); //start
6459 break;
6460
6461 default:
6462 printf("\r\n =====PCMCapture_Start : unsupported DEVICE TYPE!!!=======");
6463 ret = FALSE;
6464 break;
6465 }
6466
6467 return ret;
6468 }
6469
6470
6471 ////////////////////////////////////////////////////////////////////////////////
6472 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Stop()
6473 /// @brief \b Function \b Description: stop captrue pcm data from DDR
6474 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6475 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6476 /// @param <RET> \b NONE :
6477 /// @param <GLOBAL> \b NONE :
6478 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)6479 MS_BOOL HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)
6480 {
6481 MS_BOOL ret = TRUE;
6482 MS_U8 flagCount = 0;
6483
6484 switch(eID)
6485 {
6486 case E_DEVICE0:
6487 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0); // stop
6488 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0);
6489 do
6490 {
6491 MsOS_DelayTask(2);
6492 flagCount ++;
6493 if (flagCount > 100)
6494 {
6495 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6496 break;
6497 }
6498 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) > 0);
6499 break;
6500
6501 case E_DEVICE1:
6502 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0); //stop
6503 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0);
6504 do
6505 {
6506 MsOS_DelayTask(2);
6507 flagCount ++;
6508 if (flagCount > 100)
6509 {
6510 printf("\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
6511 break;
6512 }
6513 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) > 0);
6514 break;
6515
6516 default:
6517 printf("\r\n =====PCMCapture_Stop : unsupported DEVICE TYPE!!!=======");
6518 ret = FALSE;
6519 break;
6520 }
6521
6522 return ret;
6523 }
6524
6525
6526 ////////////////////////////////////////////////////////////////////////////////
6527 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Read()
6528 /// @brief \b Function \b Description: captrue pcm data from DDR to device
6529 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6530 /// @param <IN> \b void* : destination buffer pointer
6531 /// @param <IN> \b MS_U32 : buffer size need transfered in byte
6532 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6533 /// @param <RET> \b NONE :
6534 /// @param <GLOBAL> \b NONE :
6535 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID,void * buffer,const MS_U32 bytes)6536 MS_BOOL HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID, void* buffer, const MS_U32 bytes)
6537 {
6538 MS_BOOL ret = TRUE;
6539 MS_VIRT buffer_tmp = (MS_VIRT)buffer;
6540 MS_U32 request_size = bytes;
6541 MS_U32 read_ptr_mailbox = 0;
6542 MS_U32 write_ptr_mailbox = 0;
6543 MS_PHY pcm_capture_base_addr_tmp = 0;
6544 MS_PHY pcm_capture_read_addr_tmp = 0;
6545 MS_PHY pcm_capture_write_addr_tmp = 0;
6546 MS_S32 avail_size = 0;
6547
6548 switch(eID)
6549 {
6550 case E_DEVICE0:
6551 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE_DDR_RdPtr;
6552 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE_DDR_WrPtr;
6553 pcm_capture_base_addr_tmp = g_pcm_capture_base_addr;
6554 break;
6555
6556 case E_DEVICE1:
6557 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr;
6558 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr;
6559 pcm_capture_base_addr_tmp = g_pcm_capture2_base_addr;
6560 break;
6561
6562 default:
6563 printf("\r\n =====PCMCapture_Read : unsupported DEVICE TYPE!!!=======\n");
6564 ret = FALSE;
6565 break;
6566 }
6567
6568 if (ret == FALSE)
6569 return ret;
6570
6571 //get read & write pointer
6572 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(read_ptr_mailbox) * BYTES_IN_MIU_LINE);
6573 pcm_capture_write_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(write_ptr_mailbox) * BYTES_IN_MIU_LINE);
6574 avail_size = (MS_S32)(pcm_capture_write_addr_tmp - pcm_capture_read_addr_tmp);
6575 if (avail_size < 0)
6576 {
6577 avail_size += (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE);
6578 }
6579
6580 // if overflow , return false
6581 if (avail_size >= ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE - DSP2_PCM_CAPTURE_COPY_LINESIZE) * BYTES_IN_MIU_LINE))
6582 {
6583 printf("\r\n ===== PCM DATA OVERFLOW !!!=======\n");
6584
6585 HAL_AUDIO_PCMCapture_Stop(eID);
6586 HAL_AUDIO_PCMCapture_Start(eID);
6587 ret = FALSE;
6588 return ret;
6589 }
6590
6591 // if no enough data, do nothing.
6592 if (avail_size < request_size)
6593 {
6594 ret = FALSE;
6595 return ret;
6596 }
6597
6598 //copy data to destination.
6599 do
6600 {
6601 MS_U32 size_tmp = (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)) - pcm_capture_read_addr_tmp;
6602
6603 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
6604 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
6605
6606 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(pcm_capture_read_addr_tmp), size_tmp);
6607 MsOS_FlushMemory();
6608
6609 pcm_capture_read_addr_tmp += size_tmp;
6610 if (pcm_capture_read_addr_tmp == (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)))
6611 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp;
6612
6613 buffer_tmp += size_tmp;
6614 avail_size -= size_tmp;
6615 request_size -= size_tmp;
6616
6617 } while (request_size > 0);
6618
6619 //update read pointer
6620 HAL_AUDIO_WriteReg(read_ptr_mailbox, ((pcm_capture_read_addr_tmp - pcm_capture_base_addr_tmp) / BYTES_IN_MIU_LINE));
6621
6622 return ret;
6623 }
6624
6625 ////////////////////////////////////////////////////////////////////////////////
6626 /// @brief \b Function \b Name: HAL_AUDIO_SetDataCaptureSource()
6627 /// @brief \b Function \b Description: Select source for data capture
6628 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
6629 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
6630 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
6631 /// @param <RET> \b NONE :
6632 /// @param <GLOBAL> \b NONE :
6633 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID,AUDIO_CAPTURE_SOURCE_TYPE eSource)6634 MS_BOOL HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID, AUDIO_CAPTURE_SOURCE_TYPE eSource)
6635 {
6636 MS_U32 u32ControlAddress;
6637 MS_BOOL ret = TRUE;
6638
6639 switch(eID)
6640 {
6641 case E_DEVICE0:
6642 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL;
6643 break;
6644
6645 case E_DEVICE1:
6646 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
6647 break;
6648
6649 default:
6650 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
6651 return FALSE;
6652 }
6653
6654 switch(eSource)
6655 {
6656 case E_CAPTURE_CH5:
6657 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH5);
6658 break;
6659
6660 case E_CAPTURE_CH6:
6661 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH6);
6662 break;
6663
6664 case E_CAPTURE_CH7:
6665 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH7);
6666 break;
6667
6668 case E_CAPTURE_CH8:
6669 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH8);
6670 break;
6671
6672 case E_CAPTURE_ADC:
6673 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
6674 break;
6675
6676 case E_CAPTURE_ADC2:
6677 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
6678 break;
6679
6680 case E_CAPTURE_PCM_SE:
6681 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_Raw_Delay_SE);
6682 break;
6683
6684 case E_CAPTURE_MIXER:
6685 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_MIXER);
6686 break;
6687
6688 case E_CAPTURE_ADC1_AUIN0_INPUT:
6689 case E_CAPTURE_ADC1_AUIN1_INPUT:
6690 case E_CAPTURE_ADC1_AUIN2_INPUT:
6691 case E_CAPTURE_ADC1_AUIN3_INPUT:
6692 case E_CAPTURE_ADC1_AUIN4_INPUT:
6693 case E_CAPTURE_ADC1_AUIN5_INPUT:
6694 case E_CAPTURE_ADC1_AUMIC_INPUT:
6695 {
6696 MS_U8 u8temp = 0;
6697
6698 //check if ADC1 is occupied by main or sub channel
6699 if((LONIBBLE(g_audioSrcType) == 2 || LONIBBLE(g_audioSubSrcType) == 2))
6700 {
6701 printf("===The audio capture setting is failed by the following reason:=== \n");
6702 printf("The input setting of ADC1 is occupied by main or sub channel\n");
6703 ret = FALSE;
6704 break;
6705 }
6706
6707 //switch source of ADC1
6708 if (eSource == E_CAPTURE_ADC1_AUIN0_INPUT)
6709 {
6710 u8temp = 0x00;
6711 }
6712 else if (eSource == E_CAPTURE_ADC1_AUIN1_INPUT)
6713 {
6714 u8temp = 0x01;
6715 }
6716 else if (eSource == E_CAPTURE_ADC1_AUIN2_INPUT)
6717 {
6718 u8temp = 0x02;
6719 }
6720 else if (eSource == E_CAPTURE_ADC1_AUIN3_INPUT)
6721 {
6722 u8temp = 0x03;
6723 }
6724 else if (eSource == E_CAPTURE_ADC1_AUIN4_INPUT)
6725 {
6726 u8temp = 0x04;
6727 }
6728 else if (eSource == E_CAPTURE_ADC1_AUIN5_INPUT)
6729 {
6730 u8temp = 0x05;
6731 }
6732 else if (eSource == E_CAPTURE_ADC1_AUMIC_INPUT)
6733 {
6734 u8temp = 0x07;
6735 }
6736
6737 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, (u8temp<<4));
6738 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
6739 break;
6740 }
6741
6742 case E_CAPTURE_ADC2_AUIN0_INPUT:
6743 case E_CAPTURE_ADC2_AUIN1_INPUT:
6744 case E_CAPTURE_ADC2_AUIN2_INPUT:
6745 case E_CAPTURE_ADC2_AUIN3_INPUT:
6746 case E_CAPTURE_ADC2_AUIN4_INPUT:
6747 case E_CAPTURE_ADC2_AUIN5_INPUT:
6748 case E_CAPTURE_ADC2_AUMIC_INPUT:
6749 {
6750 MS_U8 u8temp = 0;
6751
6752 //check if ADC2 is occupied by main or sub channel
6753 if((LONIBBLE(g_audioSrcType) == 9 || LONIBBLE(g_audioSubSrcType) == 9))
6754 {
6755 printf("===The audio capture setting is faiedl by the following reason:=== \n");
6756 printf("The input setting of ADC2 is occupied by main or sub channel \n");
6757 ret = FALSE;
6758 break;
6759 }
6760
6761 //switch source of ADC2
6762 if (eSource == E_CAPTURE_ADC2_AUIN0_INPUT)
6763 {
6764 u8temp = 0x00;
6765 }
6766 else if (eSource == E_CAPTURE_ADC2_AUIN1_INPUT)
6767 {
6768 u8temp = 0x01;
6769 }
6770 else if (eSource == E_CAPTURE_ADC2_AUIN2_INPUT)
6771 {
6772 u8temp = 0x02;
6773 }
6774 else if (eSource == E_CAPTURE_ADC2_AUIN3_INPUT)
6775 {
6776 u8temp = 0x03;
6777 }
6778 else if (eSource == E_CAPTURE_ADC2_AUIN4_INPUT)
6779 {
6780 u8temp = 0x04;
6781 }
6782 else if (eSource == E_CAPTURE_ADC2_AUIN5_INPUT)
6783 {
6784 u8temp = 0x05;
6785 }
6786 else if (eSource == E_CAPTURE_ADC2_AUMIC_INPUT)
6787 {
6788 u8temp = 0x07;
6789 }
6790 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp);
6791 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
6792 break;
6793 }
6794
6795 default:
6796 printf("\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
6797 ret = FALSE;
6798 break;
6799 }
6800
6801 return ret;
6802 }
6803
_AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)6804 MS_BOOL _AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
6805 {
6806 MS_U16 time_out;
6807
6808 code_type = code_type;
6809 if ( eDspId >= AUDIO_DSP_ID_R2 )
6810 {
6811 HALAUDIO_ERROR ("%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
6812 return FALSE;
6813 }
6814
6815 if ( eDspId == AUDIO_DSP_ID_SND )
6816 {
6817 Dvb2DecCmd_tmp = HAL_AUDIO_Se_Status();
6818 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP); // Stop
6819
6820 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6821
6822 // Reset MAD module
6823 HAL_MAD2_DisEn_MIUREQ();
6824
6825 HAL_MAD2_SetDspIDMA();
6826 // Enter MCU/DSP hand-shake
6827 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG >> 8);
6828
6829 // PIO[8] interrupt
6830 HAL_MAD2_TriggerPIO8();
6831
6832 //Wait Dsp Start reload Ack
6833 time_out = 0;
6834 while ( time_out++ < 2000 )
6835 {
6836 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1 )
6837 {
6838 break;
6839 }
6840
6841 AUDIO_DELAY1MS(1);
6842 }
6843
6844 if ( time_out >= 2000 )
6845 {
6846 HALAUDIO_ERROR (" SND DSP Reload timeOut1: %d\r\n", time_out);
6847 return FALSE;
6848 }
6849
6850 // Change to IDMA Port
6851 HAL_MAD2_SetDspIDMA();
6852 }
6853
6854 return TRUE;
6855 }
6856
_AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)6857 MS_BOOL _AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
6858 {
6859 MS_U16 time_out;
6860
6861 code_type = code_type;
6862
6863 if ( eDspId >= AUDIO_DSP_ID_R2 )
6864 {
6865 HALAUDIO_ERROR ("%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
6866 return FALSE;
6867 }
6868
6869 if ( eDspId == AUDIO_DSP_ID_SND )
6870 {
6871 // Enter MCU/DSP hand-shake
6872 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END >> 8);
6873
6874 HAL_MAD2_TriggerPIO8();
6875
6876 // Wait Dsp End Reload Ack
6877 time_out = 0;
6878 while ( time_out++ < 3000 )
6879 {
6880 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2 )
6881 {
6882 break;
6883 }
6884
6885 AUDIO_DELAY1MS(1);
6886 }
6887
6888 if ( time_out >= 3000 )
6889 {
6890 HALAUDIO_ERROR (" SND DSP Reload timeOut2\r\n");
6891 return FALSE;
6892 }
6893
6894 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
6895
6896 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
6897 HAL_MAD_SetDSP2DecCmd((AU_DVB_DECCMD) Dvb2DecCmd_tmp);
6898 }
6899
6900 return TRUE;
6901 }
6902
HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id,AUDIO_DSP_CODE_TYPE code_type,void * pau_info)6903 MS_BOOL HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id, AUDIO_DSP_CODE_TYPE code_type, void * pau_info)
6904 {
6905 if ( _AudioReloadCodePreProcess(id, code_type) == FALSE )
6906 {
6907 return FALSE;
6908 }
6909
6910 // Start to Reload DSP code
6911 if ( HAL_AUDSP_DspLoadCode2((MS_U8) id, pau_info) == FALSE )
6912 {
6913 HALAUDIO_ERROR (" %s DSP Reload Fail !!\r\n", (id==AUDIO_DSP_ID_DEC ? "DEC" : "SND"));
6914 return FALSE;
6915 }
6916
6917 if ( _AudioReloadCodePostProcess(id, code_type) == FALSE )
6918 {
6919 return FALSE;
6920 }
6921
6922 return TRUE;
6923 }
6924
HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId,En_DVB_decSystemType Param)6925 MS_BOOL HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId, En_DVB_decSystemType Param)
6926 {
6927 MS_U32 regDecoderType = REG_R2_DECODE1_TYPE;
6928 MS_BOOL bRet = TRUE;
6929
6930 if(DecId == AU_DEC_ID3)
6931 {
6932 regDecoderType = REG_R2_DECODE2_TYPE;
6933 }
6934 else if (DecId == AU_DEC_ID1)
6935 {
6936 regDecoderType = REG_R2_DECODE1_TYPE;
6937 }
6938 else if (DecId == AU_DEC_ID2)
6939 {
6940 // AU_DEC_ID2 only for ATV SIF
6941 // For other case should not use AU_DEC_ID2
6942 return bRet;
6943 }
6944
6945 switch (Param)
6946 {
6947 case MSAPI_AUD_DVB_MPEG:
6948 case MSAPI_AUD_DVB_MP3:
6949 HAL_AUR2_WriteByte(regDecoderType, adec_type_mpeg);
6950 if (DecId == AU_DEC_ID3)
6951 {
6952 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
6953 }
6954 else
6955 {
6956 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
6957 }
6958 break;
6959
6960 case MSAPI_AUD_DVB_MS10_DDC:
6961 case MSAPI_AUD_DVB_AC3P:
6962 case MSAPI_AUD_DVB_AC3:
6963 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6964 HAL_AUR2_WriteByte(regDecoderType, adec_type_ac3);
6965 if (DecId == AU_DEC_ID3)
6966 {
6967 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
6968 }
6969 else
6970 {
6971 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
6972 }
6973 break;
6974
6975 case MSAPI_AUD_DVB_AAC:
6976 case MSAPI_AUD_DVB_MS10_DDT:
6977 if (g_AudioVars2->DolbyAACFlag == 1)
6978 {
6979 HAL_AUR2_WriteByte(regDecoderType, adec_type_aac);
6980 }
6981 else
6982 {
6983 HAL_AUR2_WriteByte(regDecoderType, adec_type_gaac);
6984 }
6985 HAL_MAD2_ReLoadCode(AU_DVB2_STANDARD_DDE);
6986 if (DecId == AU_DEC_ID3)
6987 {
6988 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
6989 }
6990 else
6991 {
6992 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
6993 }
6994 break;
6995
6996 case MSAPI_AUD_DVB_XPCM:
6997 HAL_AUR2_WriteByte(regDecoderType, adec_type_xpcm);
6998 if (DecId == AU_DEC_ID3)
6999 {
7000 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
7001 }
7002 else
7003 {
7004 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
7005 }
7006 break;
7007
7008 case MSAPI_AUD_DVB_RA8LBR:
7009 HAL_AUR2_WriteByte(regDecoderType, adec_type_ra8);
7010 if (DecId == AU_DEC_ID3)
7011 {
7012 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7013 }
7014 else
7015 {
7016 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
7017 }
7018 break;
7019
7020 case MSAPI_AUD_DVB_WMA:
7021 HAL_AUR2_WriteByte(regDecoderType, adec_type_wma);
7022 if (DecId == AU_DEC_ID3)
7023 {
7024 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA, TRUE);
7025 }
7026 else
7027 {
7028 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
7029 }
7030 break;
7031
7032 case MSAPI_AUD_DVB_DTS:
7033 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7034 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7035 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7036 if (DecId == AU_DEC_ID3)
7037 {
7038 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7039 }
7040 else
7041 {
7042 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7043 }
7044 break;
7045
7046 case MSAPI_AUD_DVB_WMA_PRO:
7047 HAL_AUR2_WriteByte(regDecoderType, adec_type_wmap);
7048 if (DecId == AU_DEC_ID3)
7049 {
7050 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7051 }
7052 else
7053 {
7054 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
7055 }
7056 break;
7057
7058 case MSAPI_AUD_DVB_DRA:
7059 HAL_AUR2_WriteByte(regDecoderType, adec_type_dra);
7060 if (DecId == AU_DEC_ID3)
7061 {
7062 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DRA, TRUE);
7063 }
7064 else
7065 {
7066 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
7067 }
7068 break;
7069
7070 case MSAPI_AUD_DVB_FLAC:
7071 HAL_AUR2_WriteByte(regDecoderType, adec_type_flac);
7072 if (DecId == AU_DEC_ID3)
7073 {
7074 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_FLAC, TRUE);
7075 }
7076 else
7077 {
7078 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
7079 }
7080 break;
7081
7082 case MSAPI_AUD_DVB_VORBIS:
7083 HAL_AUR2_WriteByte(regDecoderType, adec_type_vorbis);
7084 if (DecId == AU_DEC_ID3)
7085 {
7086 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7087 }
7088 else
7089 {
7090 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
7091 }
7092 break;
7093
7094 case MSAPI_AUD_DVB_AMR_NB:
7095 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7096 if (DecId == AU_DEC_ID3)
7097 {
7098 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7099 }
7100 else
7101 {
7102 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7103 }
7104 break;
7105
7106 case MSAPI_AUD_DVB_AMR_WB:
7107 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
7108 if (DecId == AU_DEC_ID3)
7109 {
7110 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
7111 }
7112 else
7113 {
7114 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
7115 }
7116 break;
7117
7118 case MSAPI_AUD_DVB_DTSHDADO:
7119 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
7120 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
7121 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
7122 if(DecId == AU_DEC_ID3)
7123 {
7124 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7125 }
7126 else
7127 {
7128 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
7129 }
7130 break;
7131
7132 default:
7133 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, Param);
7134 break;
7135 }
7136 return bRet;
7137 }
7138
AU_GetDecID(AUDIO_DEC_ID * DecPriority,AudioDecStatus_t * p_AudioDecStatus)7139 AUDIO_DEC_ID AU_GetDecID(AUDIO_DEC_ID *DecPriority, AudioDecStatus_t * p_AudioDecStatus)
7140 {
7141 MS_U8 Index = 0;
7142 AUDIO_DEC_ID DecID = AU_DEC_INVALID;
7143
7144 for(Index=0; Index<AU_DEC_MAX; Index++)
7145 {
7146 // Get Dec ID by priority
7147 DecID = DecPriority[Index];
7148 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7149 if ((HAL_MAD_GetAudioCapability(DecID, p_AudioDecStatus) == TRUE) &&
7150 (g_AudioVars2->AudioDecStatus[DecID].bConnect == FALSE))
7151 {
7152 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7153 break;
7154 }
7155 }
7156
7157 printf("DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
7158 return DecID;
7159 }
7160
HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)7161 AUDIO_DEC_ID HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)
7162 {
7163 AUDIO_DEC_ID DecRet = AU_DEC_INVALID;
7164
7165 switch (p_AudioDecStatus->eSourceType)
7166 {
7167 case E_AUDIO_INFO_ATV_IN:
7168 DecRet = AU_DEC_ID2;
7169 break;
7170
7171 case E_AUDIO_INFO_HDMI_IN:
7172 DecRet = AU_GetDecID(HDMIDecPriority, p_AudioDecStatus);
7173 break;
7174
7175 case E_AUDIO_INFO_DTV_IN:
7176 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7177 break;
7178
7179 case E_AUDIO_INFO_MM_IN:
7180 case E_AUDIO_INFO_GAME_IN:
7181 if (p_AudioDecStatus->eMMType == AUDIO_MM_VD)
7182 {
7183 DecRet = AU_GetDecID(VDDecPriority, p_AudioDecStatus);
7184 }
7185 else
7186 {
7187 DecRet = AU_GetDecID(MMDecPriority, p_AudioDecStatus);
7188 }
7189 break;
7190
7191 default:
7192 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
7193 break;
7194 }
7195
7196 printf("DecID = %d %s() %d \n",DecRet,__FUNCTION__,__LINE__);
7197 return DecRet;
7198 }
7199
HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId,AudioDecStatus_t * p_AudioDecStatus)7200 MS_BOOL HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus)
7201 {
7202 AUDIO_DSP_ID DSP_id = AUDIO_DSP_ID_ALL;
7203 MS_BOOL bRet = FALSE;
7204
7205 HALAUDIO_CHECK_SHM_INIT;
7206
7207 if ((g_AudioVars2->AudioDecStatus[DecId].eAudFormat == p_AudioDecStatus->eAudFormat) &&
7208 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == p_AudioDecStatus->eSourceType) &&
7209 (g_AudioVars2->AudioDecStatus[DecId].eGroup == p_AudioDecStatus->eGroup) &&
7210 (g_AudioVars2->AudioDecStatus[DecId].eStcSource == p_AudioDecStatus->eStcSource) &&
7211 (g_AudioVars2->AudioDecStatus[DecId].bIsAD == p_AudioDecStatus->bIsAD))
7212 {
7213 HALAUDIO_PRINT("%s() - DSP code is the same\n",__FUNCTION__);
7214 return bRet;
7215 }
7216
7217 // update occupied decoder
7218 if (DecId == AU_DEC_ID3)
7219 {
7220 DSP_id = AUDIO_DSP_ID_SND;
7221 }
7222 else if (DecId == AU_DEC_ID1)
7223 {
7224 DSP_id = AUDIO_DSP_ID_DEC;
7225 }
7226 else if (DecId == AU_DEC_ID2)
7227 {
7228 // Patch, SIF only decode in SND_DSP, but this enum is same as AUDIO_DSP_ID_SND
7229 DSP_id = AUDIO_DSP_ID_ALL;
7230 }
7231
7232 if ((p_AudioDecStatus->eAudFormat & MSAPI_AUD_ATV_NONE) == MSAPI_AUD_ATV_NONE)
7233 {
7234 AUDIO_PATH_TYPE u8SifPath;
7235 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
7236 {
7237 u8SifPath = AUDIO_PATH_6;
7238 }
7239 else
7240 {
7241 u8SifPath = AUDIO_PATH_MAIN;
7242 }
7243 HAL_AUDIO_SetInputPath(AUDIO_DSP4_SIF_INPUT , u8SifPath);
7244 }
7245 else
7246 {
7247 HAL_MAD_DvbFLockSynthesizer_En();
7248 }
7249 g_AudioVars2->AudioDecStatus[DecId].eDSPId = DSP_id;
7250 p_AudioDecStatus->eDSPId = DSP_id;
7251
7252 switch ( p_AudioDecStatus->eAudFormat)
7253 {
7254 case MSAPI_AUD_DVB_MPEG:
7255 case MSAPI_AUD_DVB_AC3:
7256 case MSAPI_AUD_DVB_AC3P:
7257 case MSAPI_AUD_DVB_MP3:
7258 case MSAPI_AUD_DVB_AAC:
7259 case MSAPI_AUD_DVB_XPCM:
7260 case MSAPI_AUD_DVB_RA8LBR:
7261 case MSAPI_AUD_DVB_WMA:
7262 case MSAPI_AUD_DVB_DTS:
7263 case MSAPI_AUD_DVB_MS10_DDT:
7264 case MSAPI_AUD_DVB_MS10_DDC:
7265 case MSAPI_AUD_DVB_WMA_PRO:
7266 case MSAPI_AUD_DVB_FLAC:
7267 case MSAPI_AUD_DVB_VORBIS:
7268 case MSAPI_AUD_DVB_AMR_NB:
7269 case MSAPI_AUD_DVB_AMR_WB:
7270 case MSAPI_AUD_DVB_DRA:
7271 bRet = HAL_AUDIO_SetSystem2(DecId, p_AudioDecStatus->eAudFormat);
7272 break;
7273
7274 case MSAPI_AUD_ATV_BTSC:
7275 bRet = HAL_SIF_SetSystem(AU_SIF_BTSC);
7276 break;
7277
7278 case MSAPI_AUD_ATV_PAL:
7279 bRet = HAL_SIF_SetSystem(AU_SIF_PALSUM);
7280 break;
7281
7282 case MSAPI_AUD_ATV_EIAJ:
7283 case MSAPI_AUD_ATV_FM_RADIO:
7284 break;
7285
7286 default:
7287 HALAUDIO_ERROR ("%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, p_AudioDecStatus->eAudFormat);
7288 break;
7289 }
7290
7291 return bRet;
7292 }
7293
7294 ////////////////////////////////////////////////////////////////////////////////
7295 /// @brief \b Function \b Name: HAL_AUDIO_GetDDRInfo()
7296 /// @brief \b Function \b Description: Return Audio DDR info
7297 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
7298 /// @param <IN> \b EN_AUDIO_DDRINFO : DDR info
7299 /// @param <OUT> \b MS_U32 : return DDR info
7300 /// @param <RET> \b NONE :
7301 /// @param <GLOBAL> \b NONE :
7302 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId,EN_AUDIO_DDRINFO DDRInfo)7303 MS_PHY HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo)
7304 {
7305 MS_PHY DDR_ADDR = 0;
7306 MS_PHY DDR_ADDR_LINE_BASE = 0;
7307 MS_PHY DDR_ADDR_TMP;
7308 MS_PHY DDR_Value = 0;
7309 if (DecId == AU_DEC_ID1)
7310 {
7311 switch(DDRInfo)
7312 {
7313 case E_AUD_MEMORY_BASE: //use DSP2 base instead
7314 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7315 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7316 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7317 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7318 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7319 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7320 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7321 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7322 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7323 DDR_Value = DDR_ADDR;
7324 break;
7325 case E_AUD_MEMORY_SIZE:
7326 //TODO
7327 break;
7328 default:
7329 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7330 break;
7331 }
7332 }
7333 else if(DecId == AU_DEC_ID3)
7334 {
7335 switch(DDRInfo)
7336 {
7337 case E_AUD_MEMORY_BASE:
7338 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
7339 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
7340 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
7341 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
7342 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
7343 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
7344 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
7345 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
7346 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
7347 DDR_Value = DDR_ADDR;
7348 break;
7349 case E_AUD_MEMORY_SIZE:
7350 //TODO
7351 break;
7352 default:
7353 HALAUDIO_ERROR ("%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
7354 break;
7355 }
7356 }
7357 else
7358 {
7359 HALAUDIO_ERROR ("%s: UN-KNOW DecId (0x%x) !!\r\n", __FUNCTION__, DecId);
7360 }
7361 return DDR_Value;
7362 }
7363
7364 ////////////////////////////////////////////////////////////////////////////////
7365 /// @brief \b Function \b Name: HAL_AUDIO_DumpDspInfo()
7366 /// @brief \b Function \b Description: Dump DSP infomation
7367 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DumpDspInfo(void)7368 void HAL_AUDIO_DumpDspInfo(void)
7369 {
7370 MS_U32 tmp_H, tmp_L, tmp_M;
7371 MS_U32 result = 0;
7372 MS_U32 ES_Lvl, PCM_Lvl;
7373 static MS_U32 preSysTime, prv_mmFile_APTS;
7374 MS_U32 sysTime, mmFile_APTS;
7375
7376 if (g_AudioDumpInfoCtrl == Audio_DumpInfo_Off)
7377 {
7378 return;
7379 }
7380
7381 ES_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
7382 PCM_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_LEVEL, ADEC1)/5;
7383
7384 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Avsync) != 0)
7385 {
7386 sysTime = MsOS_GetSystemTime();
7387 printf("[%08u]", (unsigned int)sysTime);
7388
7389 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7390 printf("ES=%03X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
7391
7392 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
7393 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
7394 printf("PCM=%04X(%04X,%04X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
7395
7396 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7397 printf("play=%X", (unsigned int)tmp_L);
7398
7399 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
7400 printf("<%04X>,", (unsigned int)tmp_L);
7401
7402 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
7403 tmp_M = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, 0, 0)&0x0F;
7404 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
7405 printf("State=%X,%X(%X)|", (unsigned int)tmp_L,(unsigned int)tmp_M, (unsigned int)tmp_H);
7406
7407 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7408 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7409 printf("frmCnt:%04X,", (unsigned int)tmp_L);
7410 printf("%04X,", (unsigned int)tmp_H);
7411
7412 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7413 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7414 printf("%02X,", (unsigned int)tmp_L);
7415 printf("%02X,", (unsigned int)tmp_H);
7416
7417 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_1STPTS_CNT, ADEC1)&0x00FF;
7418 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_STC_CNT, ADEC1)&0x00FF;
7419 tmp_M = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_FLUSH_CNT, ADEC1)&0x00FF;
7420 printf("%02X,%02X,%02X|", (unsigned int)tmp_L, (unsigned int)tmp_H, (unsigned int)tmp_M);
7421
7422 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_WR_IDX, ADEC1)&0xF;
7423 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_RD_IDX, ADEC1)&0xF;
7424 printf("tag:%01X,%01X|", (unsigned int)tmp_L, (unsigned int)tmp_H);
7425
7426 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_OFFSET, ADEC1)&0x00FFFFFF;
7427 printf("AvDly=%05X,", (unsigned int)tmp_L);
7428
7429 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_STC, ADEC1);
7430 printf("STC=%d,", (unsigned int)result/45);
7431
7432 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, ADEC1);
7433 printf("PTS=%d,", (unsigned int)result/45);
7434
7435 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
7436 printf("cPTS=%d,", (unsigned int)result/45);
7437
7438 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
7439 printf("|Td=%x\n", (unsigned int)result/90);
7440 }
7441
7442 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Dec1) != 0)
7443 {
7444 sysTime = MsOS_GetSystemTime();
7445 printf("[%08u]", (unsigned int)sysTime);
7446
7447 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7448 printf("ES=%03X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
7449
7450 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFF;
7451 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
7452 printf("PCM=%04X(%04X,%02X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
7453
7454 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_TYPE);
7455 printf("ID=%02X,", (unsigned int)tmp_L);
7456
7457 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_TYPE, ADEC1)&0x00FF;
7458 printf("Type=%02X,", (unsigned int)tmp_L);
7459
7460 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFFFF;
7461 printf("pState=%06X,", (unsigned int)tmp_L);
7462
7463 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7464 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
7465 printf("|Cmd=%02X,Stop=%02X|", (unsigned int)tmp_L, (unsigned int)tmp_H);
7466
7467 tmp_L = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER1_CFG);
7468 tmp_H = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER2_CFG);
7469 printf("Input_Mux:%02X,", (unsigned int)tmp_L&0x7);
7470 printf("%02X,", (unsigned int)tmp_H&0x7);
7471 printf("%02X|", (unsigned int)(tmp_L>>16)&0x7);
7472
7473 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7474 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7475 printf("frmCnt:%04X,", (unsigned int)tmp_L);
7476 printf("%04X,", (unsigned int)tmp_H);
7477
7478 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7479 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7480 printf("%02X,", (unsigned int)tmp_L);
7481 printf("%02X|", (unsigned int)tmp_H);
7482
7483 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FFFF;
7484 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x0000FFFF;
7485 printf("Call:%04X,", (unsigned int)tmp_L);
7486 printf("sMiss:%04X|", (unsigned int)tmp_H);
7487
7488 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
7489 printf("pcm=%06X,", (unsigned int)tmp_L); //need get from DSP
7490
7491 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_R, DSP_MEM_TYPE_DM)&0x00FFFFFF;
7492 printf("%06X|", (unsigned int)tmp_L); //need get from DSP
7493
7494 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7495 printf("play=%X\n", (unsigned int)tmp_L);
7496 }
7497
7498
7499 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_IoInfo) != 0)
7500 {
7501 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH5_CFG)) & 0x000F;
7502 printf("CH5 mux=0x%02X,", (unsigned int)tmp_L);
7503
7504 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH6_CFG)) & 0x000F;
7505 printf("Ch6 mux=0x%02X,", (unsigned int)tmp_L);
7506
7507 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH7_CFG)) & 0x000F;
7508 printf("Ch7 mux=0x%02X", (unsigned int)tmp_L);
7509
7510 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
7511 printf("|DEC1=0x%06X,", (unsigned int)tmp_L); //need get from DSP
7512
7513 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
7514 printf("DEC2=0x%06X", (unsigned int)tmp_L); //need get from DSP
7515
7516 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_RAW+0, DSP_MEM_TYPE_DM);
7517 printf("|CH5=0x%06X,", (unsigned int)tmp_L);
7518
7519 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_MUL_CH6+0, DSP_MEM_TYPE_DM);
7520 printf("CH6=0x%06X,", (unsigned int)tmp_L);
7521
7522 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_SCART+0, DSP_MEM_TYPE_DM);
7523 printf("CH7=0x%06X", (unsigned int)tmp_L);
7524
7525 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_DAC1_OUT+0, DSP_MEM_TYPE_DM);
7526 printf("|DAC1=0x%06X,", (unsigned int)tmp_L);
7527
7528 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_IIS1_OUT+0, DSP_MEM_TYPE_DM);
7529 printf("I2S=0x%06X,", (unsigned int)tmp_L);
7530
7531 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_SPDIF_OUT+0, DSP_MEM_TYPE_DM);
7532 printf("SPDIF=0x%06X\n", (unsigned int)tmp_L);
7533 }
7534
7535 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_AutoTest) != 0)
7536 {
7537 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x00FFFFFF;
7538 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x00FFFFFF;
7539 printf("[AutoTest][AUDIO][FrameCount][%d]\n", (unsigned int)tmp_L);
7540 printf("[AutoTest][AUDIO][ErrorCount][%d]\n", (unsigned int)tmp_H);
7541
7542 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
7543 printf("[AutoTest][AUDIO][SampleRate][%d]\n", (unsigned int)tmp_L);
7544 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
7545 printf("[AutoTest][AUDIO][ACMod][%d]\n", (unsigned int)tmp_L);
7546 }
7547
7548 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_mmFileAVsync) != 0)
7549 {
7550 sysTime = MsOS_GetSystemTime();
7551 printf("[%08u](%03u):", (unsigned int)sysTime, (unsigned int)(sysTime - preSysTime));
7552 preSysTime = sysTime;
7553
7554 mmFile_APTS = HAL_MAD_GetCommInfo(Audio_Comm_infoType_1ms_PTS);
7555 printf("APTS:%07u(%03u)|", (unsigned int)mmFile_APTS, (unsigned int)(mmFile_APTS - prv_mmFile_APTS));
7556 prv_mmFile_APTS = mmFile_APTS;
7557
7558 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1)&0xFFFF;
7559 printf("MM:%04X|", (unsigned int)tmp_H);
7560
7561 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
7562 printf("ES=%04X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
7563
7564 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFF;
7565 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
7566 printf("PCM=%04X(%06X,%02X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
7567
7568 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
7569 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
7570 printf("Cmd=%02X,Stop=%02X,", (unsigned int)tmp_L, (unsigned int)tmp_H);
7571
7572 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
7573 printf("play=%X", (unsigned int)tmp_L);
7574
7575 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
7576 printf("<%04X>,", (unsigned int)tmp_L);
7577
7578 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
7579 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
7580 printf("State=%X(%X)|", (unsigned int)tmp_L, (unsigned int)tmp_H);
7581
7582 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
7583 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
7584 printf("frmCnt:%04X,", (unsigned int)tmp_L);
7585 printf("%04X,", (unsigned int)tmp_H);
7586
7587 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
7588 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
7589 printf("%02X,", (unsigned int)tmp_L);
7590 printf("%02X|", (unsigned int)tmp_H);
7591
7592 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_ID, DSP_MEM_TYPE_DM)&0x00FF;
7593 //printf("DEC_ID=%02X,", tmp_L);
7594
7595 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_DEC_TYPE, DSP_MEM_TYPE_DM)&0x00FF;
7596 //printf("Type=%02X,", tmp_L);
7597
7598 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFF;
7599 printf("pState=%04X,", (unsigned int)tmp_L);
7600
7601 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FF;
7602 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x00000FFF;
7603 printf("Call:%02X,", (unsigned int)tmp_L);
7604 printf("Miss:%03X\n", (unsigned int)tmp_H);
7605 }
7606
7607 }
7608
7609
7610 #ifndef MSOS_TYPE_NUTTX
HAL_AUDIO_ResetTeeInfoShmToDefault(void)7611 MS_BOOL HAL_AUDIO_ResetTeeInfoShmToDefault(void)
7612 {
7613 if (pAudioTeeInfoShm == NULL)
7614 {
7615 return FALSE;
7616 }
7617 memset(pAudioTeeInfoShm, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
7618 audio_tee_enabled = g_bAudioTeeEnabled;
7619 audio_tee_mbx_initialized = g_bAudioTeeMbxInitialized;
7620 dec_dsp_secure_tee_accessed = g_bDecDspSecureTeeAccessed;
7621 snd_dsp_secure_tee_accessed = g_bSndDspSecureTeeAccessed;
7622 return TRUE;
7623 }
7624
HAL_AUDIO_AllocateTeeInfoShm(void)7625 AUDIO_TEE_INFO_SHARE_MEM *HAL_AUDIO_AllocateTeeInfoShm(void)
7626 {
7627 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7628 MS_U32 u32ShmId = 0;
7629 AUDIO_TEE_INFO_SHARE_MEM *virtAddr = 0;
7630 MS_U32 u32BufSize = 0;
7631
7632 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)
7633 {
7634 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7635
7636 if (pAudioTeeInfoShm->g_u32ClientCounter == 0)
7637 {
7638 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7639 HAL_AUDIO_ResetTeeInfoShmToDefault();
7640 }
7641 }
7642 else
7643 {
7644 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)
7645 {
7646 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7647 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
7648
7649 HALAUDIO_PRINT("reset Audio TEE Info SHM data ...\n");
7650 HAL_AUDIO_ResetTeeInfoShmToDefault();
7651 }
7652 else
7653 {
7654 HALAUDIO_ERROR("SHM allocation for Audio TEE Info failed!\n");
7655 return NULL;
7656 }
7657 }
7658
7659 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7660 {
7661 g_bAudioTeeInfoShmInitFlag = TRUE;
7662 pAudioTeeInfoShm->g_u32ClientCounter++;
7663 }
7664 #else
7665 pAudioTeeInfoShm = &gAudioTeeInfoShm;
7666
7667 if (g_bAudioTeeInfoShmInitFlag == FALSE)
7668 {
7669 HALAUDIO_PRINT("Audio TEE Info SHM is created...\n");
7670 g_bAudioTeeInfoShmInitFlag = TRUE;
7671
7672 HAL_AUDIO_ResetTeeInfoShmToDefault();
7673 pAudioTeeInfoShm->g_u32ClientCounter++;
7674 }
7675 #endif
7676 return pAudioTeeInfoShm;
7677 }
7678
HAL_AUDIO_DeAllocateTeeInfoShm(void)7679 MS_BOOL HAL_AUDIO_DeAllocateTeeInfoShm(void)
7680 {
7681 AUDIO_TEE_INFO_SHARE_MEM * pAUDIOShared = NULL;
7682
7683 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
7684 MS_U32 u32ShmId = 0;
7685 MS_VIRT virtAddr = 0;
7686 MS_U32 u32BufSize = 0;
7687
7688 if (g_bAudioTeeInfoShmInitFlag == TRUE)
7689 {
7690 g_bAudioTeeInfoShmInitFlag = FALSE;
7691
7692 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, &virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
7693 {
7694 HALAUDIO_ERROR("%s() : No AUDIO TEE Info SHM is created!\n", __FUNCTION__);
7695 return FALSE;
7696 }
7697
7698 pAUDIOShared = (AUDIO_TEE_INFO_SHARE_MEM *)virtAddr;
7699 pAUDIOShared->g_u32ClientCounter--;
7700
7701 if (pAUDIOShared->g_u32ClientCounter == 0)
7702 {
7703 printf("free Audio TEE Info SHM data ...\n");
7704 #if defined(MSOS_TYPE_LINUX)
7705 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, u32ShmId) == TRUE)
7706 {
7707 HALAUDIO_PRINT("Audio TEE Info SHM data is freed\n");
7708 }
7709 else
7710 {
7711 HALAUDIO_ERROR("%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
7712 return FALSE;
7713 }
7714 #endif
7715 }
7716 }
7717 #else
7718 pAUDIOShared = &gAudioTeeInfoShm;
7719
7720 if (g_bAudioTeeInfoShmInitFlag == TRUE)
7721 {
7722 HALAUDIO_PRINT("free Audio TEE Info SHM data ...\n");
7723 g_bAudioTeeInfoShmInitFlag = FALSE;
7724
7725 memset(pAUDIOShared, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
7726 }
7727 #endif
7728
7729 return TRUE;
7730 }
7731
HAL_AUDIO_RegisterMBX(void)7732 MS_BOOL HAL_AUDIO_RegisterMBX(void)
7733 {
7734 MS_U8 ClassNum=0;
7735 MBX_Result result;
7736 MBX_CPU_ID eHKCPU;
7737 MS_U32 u32TimeoutMillSecs = 10000;
7738
7739 if (pAudioTeeInfoShm == NULL)
7740 return FALSE;
7741 if (audio_tee_mbx_initialized == TRUE)
7742 return TRUE;
7743
7744 #if 1
7745 eHKCPU = E_MBX_CPU_MIPS;
7746 if ( E_MBX_SUCCESS != MApi_MBX_Init(eHKCPU, E_MBX_ROLE_HK, u32TimeoutMillSecs))
7747 {
7748 DBG_AUDIO_ERROR("Error> MBX init failed !!\n");
7749 return FALSE;
7750 }
7751 else
7752 {
7753 MApi_MBX_Enable(TRUE);
7754 }
7755 #endif
7756
7757 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass (E_MBX_CPU_MIPS_VPE1, "MAD", (MS_U8 *)&ClassNum))
7758 {
7759 DBG_AUDIO_ERROR("MAD MApi_MBX_QueryDynamicClass fail\n");
7760
7761 return FALSE;
7762 }
7763 result = MApi_MBX_RegisterMSG(ClassNum, 10);
7764 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
7765 {
7766 DBG_AUDIO_ERROR("HAL_AUDIO_RegisterMBX fail");
7767 return FALSE;
7768 }
7769 else
7770 {
7771 TEE_MBX_MSG_CLASS_SET(ClassNum);
7772 DBG_AUDIO("HAL_AUDIO_RegisterMBX ok");
7773 return TRUE;
7774 }
7775 }
7776
HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)7777 TEE_TO_REE_MBX_ACK_MSG_TYPE HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)
7778 {
7779 MS_U8 u8Index;
7780 MBX_Result result;
7781 REE_TO_TEE_MBX_MSG_TYPE msg_type1 = REE_TO_TEE_MBX_MSG_NULL;
7782
7783 AUDIO_TEE_INFO_SHM_CHECK_NULL;
7784
7785 if (audio_tee_enabled == FALSE)
7786 {
7787 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
7788 }
7789 if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_DEC) == (REE_TO_TEE_MBX_MSG_TYPE_DEC))
7790 {
7791 if (dec_dsp_secure_tee_accessed == FALSE)
7792 {
7793 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
7794 }
7795 else
7796 {
7797 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_DEC);
7798 }
7799 }
7800 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_SE) == (REE_TO_TEE_MBX_MSG_TYPE_SE))
7801 {
7802 if (snd_dsp_secure_tee_accessed == FALSE)
7803 {
7804 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
7805 }
7806 else
7807 {
7808 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_SE);
7809 }
7810 }
7811 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_GENERAL) == (REE_TO_TEE_MBX_MSG_TYPE_GENERAL))
7812 {
7813
7814 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
7815 }
7816
7817 if (audio_tee_mbx_initialized == FALSE)
7818 {
7819 return TEE_TO_REE_MBX_ACK_MSG_INVALID;
7820 }
7821 REE_TO_TEE_MBX_MSG_INIT;
7822 MBX_MSG_SET_CLASSID(ree_to_tee_mbx_msg, tee_mbx_msg_class);
7823 MBX_MSG_SET_CMD(ree_to_tee_mbx_msg, msg_type1);
7824
7825 result = MApi_MBX_SendMsg(&(ree_to_tee_mbx_msg));
7826 if (E_MBX_SUCCESS!= result)
7827 {
7828 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
7829 }
7830 // Receive Reply ACK from TEE side.
7831 memset(&(tee_to_ree_mbx_msg), 0, sizeof(MBX_Msg));
7832 MBX_MSG_SET_CLASSID(tee_to_ree_mbx_msg, tee_mbx_msg_class);
7833 do
7834 {
7835 result = MApi_MBX_RecvMsg(tee_mbx_msg_class, &(tee_to_ree_mbx_msg), 2000, MBX_CHECK_INSTANT_MSG);
7836 } while(E_MBX_SUCCESS != result);
7837
7838 u8Index = tee_to_ree_mbx_msg.u8Index;
7839 DBG_AUDIO("Recv TEE Ack Msg OK cmd:%x\n", u8Index);
7840
7841 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL == u8Index)
7842 {
7843 DBG_AUDIO_ERROR("RecvMsg TEE_TO_REE_MBX_MSG_ACK_FAIL..\n");
7844 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
7845 }
7846 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS == u8Index)
7847 {
7848 DBG_AUDIO("RecvMsg TEE_TO_REE_MBX_MSG_ACK_SUCCESS..\n");
7849 }
7850
7851 return TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
7852 }
7853 #else
_MAD_Proc(void)7854 static void _MAD_Proc(void)
7855 {
7856 MS_U32 u32Events;
7857 MS_U8 u8Index = 0;
7858 MBX_Result result;
7859
7860 DBG_AUDIO("_MAD_Proc...........\n");
7861
7862 while (1)
7863 {
7864 MsOS_WaitEvent(_s32MadEventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
7865 u8Index = msg.u8Index;
7866
7867 memset(&TeeToReeMbxAckMsg, 0, sizeof(MBX_Msg));
7868 TEE_TO_REE_MBX_MSG_INIT(TeeToReeMbxAckMsg);
7869 MBX_MSG_SET_CLASSID(TeeToReeMbxAckMsg, msg.u8MsgClass);
7870 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS);
7871
7872 switch ( u8Index )
7873 {
7874 case REE_TO_TEE_MBX_MSG_HAL_AUDSP_DspLoadCode:
7875 {
7876 if (HAL_AUDSP_DspLoadCode(msg.u8Parameters[0]) == FALSE)
7877 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
7878
7879 break;
7880 }
7881
7882 case REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr:
7883 {
7884 MS_U32 u32Bin_Base_Address, u32Mad_Base_Buffer_Adr;
7885 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));
7886 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));
7887 HAL_AUDIO_SetDspBaseAddr(msg.u8Parameters[0], u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
7888 break;
7889 }
7890
7891 default:
7892 {
7893 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
7894 break;
7895 }
7896 }
7897
7898 result = MApi_MBX_SendMsg(&TeeToReeMbxAckMsg);
7899 if (E_MBX_SUCCESS != result)
7900 DBG_AUDIO("MAD Reply Ack fail classid: %x cmd:%x \n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
7901 else
7902 DBG_AUDIO("MAD Reply Ack ok classid:%x cmd:%x\n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
7903 }
7904 }
7905
HAL_AUDIO_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)7906 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
7907 {
7908 if(pMsg==NULL)
7909 {
7910 DBG_AUDIO("pMsg is a null pointer\n");
7911 return;
7912 }
7913 if (_s32MadEventId < 0)
7914 {
7915 DBG_AUDIO("MAD EventGroup Id is not valid...\n");
7916 return;
7917 }
7918 memcpy(&msg, pMsg, sizeof(MBX_Msg));
7919 MsOS_SetEvent(_s32MadEventId, 1);
7920 return;
7921 }
7922 #endif
7923
7924 ////////////////////////////////////////////////////////////////////////////////
7925 /// @brief \b Function \b Name: HAL_AUDIO_update_DspUsage()
7926 /// @brief \b Function \b Description: update DSP resource status when select input source
7927 /// @param <IN> \b AUDIO_SOURCE_INFO_TYPE : select input source type
7928 /// @param <OUT> \b NONE :
7929 /// @param <RET> \b NONE :
7930 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)7931 void HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)
7932 {
7933 HALAUDIO_CHECK_SHM_INIT;
7934
7935 /* same input source, not update */
7936 if ( g_AudioVars2->eMainSourceType == eSourceType )
7937 {
7938 return;
7939 }
7940
7941 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
7942
7943 HALAUDIO_PRINT ("%s: PrevSource %d NowSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType, eSourceType);
7944
7945 /* release prev DSP resource */
7946 if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN && eSourceType != E_AUDIO_INFO_DTV_IN) )
7947 {
7948 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = FALSE;
7949 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
7950 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_NONE;
7951 HALAUDIO_PRINT ("%s: Release DEC DSP from DTV !!\r\n", __FUNCTION__);
7952 }
7953 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN && eSourceType != E_AUDIO_INFO_ATV_IN) )
7954 {
7955 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
7956 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
7957 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
7958 HALAUDIO_PRINT ("%s: Release SND DSP from ATV !!\r\n", __FUNCTION__);
7959 }
7960 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN && eSourceType != E_AUDIO_INFO_HDMI_IN) )
7961 {
7962 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
7963 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
7964 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
7965 HALAUDIO_PRINT ("%s: Release SND DSP from HDMI !!\r\n", __FUNCTION__);
7966 }
7967
7968 g_AudioVars2->ePrevSourceType = g_AudioVars2->eMainSourceType;
7969 g_AudioVars2->eMainSourceType = eSourceType;
7970
7971 /* lock main input source DSP resource */
7972 if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN )
7973 {
7974 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = TRUE;
7975 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
7976 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_DTV;
7977 HALAUDIO_PRINT ("%s: Alloc DEC DSP for DTV !!\r\n", __FUNCTION__);
7978 }
7979 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN )
7980 {
7981 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
7982 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
7983 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_ATV;
7984 HALAUDIO_PRINT ("%s: Alloc DEC DSP for ATV !!\r\n", __FUNCTION__);
7985 }
7986 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN )
7987 {
7988 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
7989 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
7990 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_HDMI;
7991 HALAUDIO_PRINT ("%s: Alloc DEC DSP for HDMI !!\r\n", __FUNCTION__);
7992 }
7993
7994 HALAUDIO_PRINT ("%s: update PrevSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType);
7995
7996 OS_RELEASE_MUTEX(_s32MutexLoadCode);
7997 }
7998
HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id)7999 Audio_id HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id) //temp
8000 {
8001 Audio_id ADEC_id;
8002 switch(dec_id)
8003 {
8004 case AU_DEC_INVALID:
8005 case AU_DEC_MAX:
8006 printf("[Error] Can't convert...\n");
8007 ADEC_id = ADEC3; //no usage just take one for it...
8008 break;
8009
8010 case AU_DEC_ID1:
8011 ADEC_id = ADEC1;
8012 break;
8013
8014 case AU_DEC_ID2:
8015 case AU_DEC_ID3:
8016 ADEC_id = ADEC2;
8017 break;
8018
8019 default:
8020 ADEC_id = ADEC3;
8021 break;
8022 }
8023 return ADEC_id;
8024 }
8025
8026 ////////////////////////////////////////////////////////////////////////////////
8027 /// @brief \b Function \b Name: HAL_AUDIO_GetCaps()
8028 /// @brief \b Function \b Description: Get Audio Capabilities
8029 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
8030 /// @param <IN> \b MS_U32 * : Audio Capabilites pointer
8031 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
8032 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId,MS_U32 * pCaps)8033 MS_U32 HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId, MS_U32 *pCaps)
8034 {
8035 AUDIO_CAPABILITIES *pCapsTmp = NULL;
8036 MS_U32 u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
8037
8038 HALAUDIO_CHECK_SHM_INIT;
8039
8040 if (pCaps == NULL)
8041 {
8042 HALAUDIO_ERROR("%s: Error! pCaps should not be NULL!\n", __FUNCTION__);
8043 return FALSE;
8044 }
8045
8046 if ((DecId <= AU_DEC_INVALID) || (DecId >= AU_DEC_MAX) || (DecId == AU_DEC_ID2))
8047 {
8048 HALAUDIO_ERROR("%s: Error! Invalid DecId (%d)!\n", __FUNCTION__, DecId);
8049 return FALSE;
8050 }
8051 else if ((g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum == 1) && (DecId > AU_DEC_ID1))
8052 {
8053 HALAUDIO_ERROR("%s: Error! DecId (%d) is greater than max decoder number (%d)!\n", __FUNCTION__, DecId, g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum);
8054 return FALSE;
8055 }
8056
8057 pCapsTmp = (AUDIO_CAPABILITIES *)pCaps;
8058
8059 if (pCapsTmp->u32AudioCapsVersion == 0)
8060 {
8061 HALAUDIO_ERROR("%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion);
8062 return FALSE;
8063 }
8064
8065 if (pCapsTmp->u32AudioCapsStructSize == 0)
8066 {
8067 HALAUDIO_ERROR("%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsStructSize);
8068 return FALSE;
8069 }
8070
8071 if (pCapsTmp->u32AudioCapsVersion != g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion)
8072 {
8073 HALAUDIO_ERROR("%s: Warning! function caller's version (%u) is not matched to driver's version (%u) at DecId (%d)\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion, (unsigned int)g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion, DecId);
8074
8075 u32AudioCapsStructSize = (u32AudioCapsStructSize <= pCapsTmp->u32AudioCapsStructSize) ? u32AudioCapsStructSize : pCapsTmp->u32AudioCapsStructSize;
8076 }
8077
8078 memcpy((void *)pCapsTmp, (void *)&g_AudioVars2->AudioCaps[DecId], u32AudioCapsStructSize);
8079
8080 return TRUE;
8081 }
8082
8083 ////////////////////////////////////////////////////////////////////////////////
8084 /// @brief \b Function \b Name: HAL_AUDIO_SET_IPAUTH()
8085 /// @brief \b Function \b Description: HAL_AUDIO_SET_IPAUTH register
8086 /// @param <IN> \b MS_U32 ip_auth
8087 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)8088 void HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)
8089 {
8090 if (REG_AUDIO_IPAUTH != 0)
8091 {
8092 HAL_MAD_Write_DSP_sram(REG_AUDIO_IPAUTH, ip_auth, DSP_MEM_TYPE_PM);
8093 }
8094 else
8095 {
8096 HAL_MAD2_Write_DSP_sram(REG_DEC2_AUDIO_IPAUTH, ip_auth, DSP_MEM_TYPE_PM);
8097 }
8098 }
8099
8100 ////////////////////////////////////////////////////////////////////////////////
8101 /// @brief \b Function \b Name: HAL_AUDIO_Set_DecimationMode()
8102 /// @brief \b Function \b Description: HAL_AUDIO_Set_Decimation register
8103 /// @param <IN> \b AUDIO_OUTPUT_TYPE Output_Type: Audio Output type
8104 /// @param <IN> \b MS_BOOL Enable : Audio ID: ADEC ID
8105 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type,Audio_id ID)8106 void HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type, Audio_id ID)
8107 {
8108
8109 switch(Output_Type)
8110 {
8111 case AUDIO_HDMI_OUTPUT: //high rate nonPCM application need decimation
8112 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))
8113 {
8114 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x04);
8115 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x10);
8116 }
8117 else
8118 {
8119 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x00);
8120 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x00);
8121 }
8122 break;
8123
8124 case AUDIO_HDMI_ARC_OUTPUT:
8125 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8126 {
8127 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x02);
8128 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x08);
8129 }
8130 else
8131 {
8132 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x00);
8133 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x00);
8134 }
8135 break;
8136
8137 case AUDIO_SPDIF_OUTPUT:
8138 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
8139 {
8140 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x01);
8141 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x04);
8142 }
8143 else
8144 {
8145 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x00);
8146 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x00);
8147 }
8148 break;
8149
8150 default:
8151 break;
8152 }
8153 }
8154
8155 ////////////////////////////////////////////////////////////////////////////////
8156 /// @brief \b Function \b Name: HAL_AUDIO_CheckPlayDone()
8157 /// @brief \b Function \b Description: Check file play done. If file play done, will return TRUE
8158 /// @param <IN> \b NONE :
8159 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8160 /// @param <GLOBAL> \b NONE :
8161 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckPlayDone(void)8162 MS_BOOL HAL_AUDIO_CheckPlayDone(void)
8163 {
8164 if ( ((HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_okFrmCnt) !=0) ||
8165 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_errFrmCnt) !=0)) &&
8166 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_pcmBuf_currLevel) == 0))
8167 {
8168 return TRUE;
8169 }
8170 return FALSE;
8171 }
8172
8173 ////////////////////////////////////////////////////////////////////////////////
8174 /// @brief \b Function \b Name: HAL_AUDIO_CheckVersionInfo()
8175 /// @brief \b Function \b Description: Check Version info
8176 /// @param <IN> \b NONE :
8177 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
8178 /// @param <GLOBAL> \b NONE :
8179 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckVersionInfo(void)8180 MS_BOOL HAL_AUDIO_CheckVersionInfo(void)
8181 {
8182 HALAUDIO_PRINT("\r\n \033[1;32m==========Audio R2 & DSP Version Check==================\033[0m");
8183 HALAUDIO_PRINT("\r\n \033[1;32m DEC-R2:0x%06X \033[0m \r\n", DEC_R2_VERSION);
8184 #if ASND_R2_SUPPORT
8185 HALAUDIO_PRINT("\r\n \033[1;32m SND-R2:%06X \033[0m \r\n", SND_R2_VERSION);
8186 #endif
8187 HALAUDIO_PRINT("\r\n \033[1;32m DSP System:0x%06X \033[0m \r\n", system_version_num);
8188
8189 if(HAL_AUDIO_AbsReadReg(MBOX_D2M_03AA) != DEC_R2_VERSION) // Compare DEC R2 Version with Mail Box
8190 {
8191 HALAUDIO_PRINT("\r\n \033[1;32m Audio DEC-R2 Version Mismatch!!!!!!! \033[0m \r\n");
8192 }
8193 return TRUE;
8194 }
8195
HAL_AUDIO_Pcm_Dump_Setting(MS_U32 u32alue,MS_U32 * pData)8196 MS_S32 HAL_AUDIO_Pcm_Dump_Setting(MS_U32 u32alue, MS_U32 *pData)
8197 {
8198 return 0;
8199 }
8200
HAL_AUDIO_Pcm_Check_U32_Param_Valid(MS_U32 u32alue,MS_U32 * pData,MS_U32 u32Count)8201 MS_S32 HAL_AUDIO_Pcm_Check_U32_Param_Valid(MS_U32 u32alue, MS_U32 *pData, MS_U32 u32Count)
8202 {
8203 MS_U32 u32Loop = 0;
8204 MS_S32 s32Ret = -A_EINVAL;
8205
8206 if (u32Count == 0)
8207 {
8208 return -A_EINVAL;
8209 }
8210
8211 if (pData != NULL)
8212 {
8213 for (u32Loop = 0; u32Loop < u32Count ; u32Loop++)
8214 {
8215 if (pData[u32Loop] == 0)
8216 {
8217 break;
8218 }
8219
8220 if (u32alue == pData[u32Loop])
8221 {
8222 s32Ret = 0;
8223 break;
8224 }
8225 }
8226 }
8227 else
8228 {
8229 s32Ret = -A_EFAULT;
8230 }
8231
8232 return s32Ret;
8233 }
8234
HAL_AUDIO_Pcm_HwDma_Reader1_Apply_Setting(void)8235 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Apply_Setting(void)
8236 {
8237 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8238 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8239 MS_U16 u16Divisor = 0;
8240 MS_U16 u16Synthrate = 0;
8241 MS_U32 u32TargetBufferSize = 0;
8242 MS_U32 u32TargetChannel = 0;
8243 MS_S32 s32Ret = 0;
8244
8245 /*
8246 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
8247 */
8248 switch(pPcmInfo->u32SampleRate) {
8249 case 8000:
8250 {
8251 u16Divisor = 2;
8252 u16Synthrate = 0x6978;
8253 break;
8254 }
8255
8256 case 11025:
8257 {
8258 u16Divisor = 2;
8259 u16Synthrate = 0x4C87;
8260 break;
8261 }
8262
8263 case 12000:
8264 {
8265 u16Divisor = 2;
8266 u16Synthrate = 0x4650;
8267 break;
8268 }
8269
8270 case 16000:
8271 {
8272 u16Divisor = 1;
8273 u16Synthrate = 0x6978;
8274 break;
8275 }
8276
8277 case 22050:
8278 {
8279 u16Divisor = 1;
8280 u16Synthrate = 0x4C87;
8281 break;
8282 }
8283
8284 case 24000:
8285 {
8286 u16Divisor = 1;
8287 u16Synthrate = 0x4650;
8288 break;
8289 }
8290
8291 case 32000:
8292 {
8293 u16Divisor = 0;
8294 u16Synthrate = 0x6978;
8295 break;
8296 }
8297
8298 case 44100:
8299 {
8300 u16Divisor = 0;
8301 u16Synthrate = 0x4C87;
8302 break;
8303 }
8304
8305 case 48000:
8306 {
8307 u16Divisor = 0;
8308 u16Synthrate = 0x4650;
8309 break;
8310 }
8311
8312 default:
8313 {
8314 u16Divisor = 0;
8315 u16Synthrate = 0x4650;
8316 pPcmInfo->u32SampleRate = 48000;
8317 break;
8318 }
8319 }
8320
8321 /* enable DMA synthesizer */
8322 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG0, 0x20, 0x20);
8323
8324 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
8325 HAL_AUDIO_WriteMaskReg(REG_AUDIO_CLK_CFG6, 0x6000, (u16Divisor << 13));
8326 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_SYNTH_NF, 0xFFFF, u16Synthrate);
8327
8328 /* calculate buffer size */
8329 u32TargetChannel = 2;
8330 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2 * 2) / 1000;
8331 if (u32TargetBufferSize > HW_DMA_RDR1_BUF_SIZE)
8332 {
8333 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);
8334 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE;
8335 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * 2 * 2));
8336 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
8337 }
8338
8339 /* set buffer size */
8340 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_3, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
8341
8342 /* set overrun & underrun threshold */
8343 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_4, 0xFFFF, u32TargetBufferSize - 12);
8344 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_5, 0xFFFF, 0x0012);
8345
8346 pPCM->u8SettingChangeFlag = FALSE;
8347
8348 return s32Ret;
8349 }
8350
HAL_AUDIO_Pcm_HwDma_Reader1_Restart(void)8351 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Restart(void)
8352 {
8353 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8354 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8355 MS_S32 s32Ret = 0;
8356
8357 if (pPcmInfo->u8ConnectFlag == FALSE)
8358 {
8359 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8360 return -A_EPERM;
8361 }
8362
8363 /* clear PCM buffer */
8364 memset((void *)pPcmInfo->pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
8365
8366 /* flush MIU */
8367 MsOS_FlushMemory();
8368
8369 /* clear engine's write pointer */
8370 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, 0x0000);
8371
8372 /* reset & start engine */
8373 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x6402);
8374 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x2402);
8375
8376 /* reset write pointer */
8377 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
8378
8379 /* reset remain size */
8380 pPCM->u32RemainSize = 0;
8381
8382 return s32Ret;
8383 }
8384
HAL_AUDIO_Pcm_HwDma_Reader1_Init(void * pData)8385 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Init(void *pData)
8386 {
8387 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8388 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8389 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
8390 MS_U32 u32TargetBufferAddrPa = 0;
8391 MS_U32 u32TargetBufferSize = 0;
8392 MS_U32 u32TargetChannel = 0;
8393 MS_S32 s32Ret = 0;
8394 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
8395
8396 if (pData == NULL)
8397 {
8398 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
8399 return -A_EFAULT;
8400 }
8401
8402 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
8403
8404 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
8405 {
8406 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
8407 return -A_EINVAL;
8408 }
8409
8410 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
8411 {
8412 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
8413 return -A_EINVAL;
8414 }
8415
8416 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8417 {
8418 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8419 return -A_EINVAL;
8420 }
8421
8422 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8423 {
8424 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
8425 return -A_EINVAL;
8426 }
8427
8428 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)
8429 {
8430 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
8431 return -A_EINVAL;
8432 }
8433
8434 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)
8435 {
8436 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
8437 return -A_EINVAL;
8438 }
8439
8440 u32TargetChannel = 2;
8441 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * 2 * 2) / 1000;
8442 if (u32TargetBufferSize > HW_DMA_RDR1_BUF_SIZE)
8443 {
8444 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);
8445 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE;
8446 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * 2 * 2));
8447 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
8448 }
8449
8450 /* fill in settings */
8451 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8452 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
8453 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
8454 pPcmInfo->u8ConnectFlag = TRUE;
8455 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
8456 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
8457 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
8458 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
8459 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
8460 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
8461 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
8462 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
8463 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
8464 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
8465 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
8466 HAL_AUDIO_Pcm_HwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
8467
8468 /* init PCM buffer address */
8469 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR;
8470 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
8471 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
8472 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
8473
8474 /* set PCM buffer address */
8475 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DMA_RD_CTRL_7, 0xFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFF)); /* RD_BASE_ADDR[7:0] */
8476 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_2, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 8) & 0xFFFF)); /* RD_BASE_ADDR[23:8] */
8477 HAL_AUDIO_WriteMaskByte((REG_AUDIO_DMA_RD_CTRL_7 + 1), 0x0F, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 24) & 0x0F)); /* RD_BASE_ADDR[27:24] */
8478
8479 /* set SEL_CLK_DMA_READER */
8480 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG6, 0x07, 0x04);
8481
8482 /* apply setting */
8483 HAL_AUDIO_Pcm_HwDma_Reader1_Apply_Setting();
8484
8485 /* restart */
8486 HAL_AUDIO_Pcm_HwDma_Reader1_Restart();
8487
8488 return s32Ret;
8489 }
8490
HAL_AUDIO_Pcm_HwDma_Reader1_Exit(void)8491 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Exit(void)
8492 {
8493 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8494 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8495 MS_S32 s32Ret = 0;
8496 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
8497
8498 if (pPcmInfo->u8ConnectFlag != FALSE)
8499 {
8500 HAL_AUDIO_Pcm_HwDma_Reader1_Flush();
8501 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
8502 }
8503
8504 return s32Ret;
8505 }
8506
HAL_AUDIO_Pcm_HwDma_Reader1_Start(void)8507 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Start(void)
8508 {
8509 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8510 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8511 MS_S32 s32Ret = 0;
8512 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
8513
8514 if (pPcmInfo->u8StartFlag == FALSE)
8515 {
8516 if (pPCM->u8SettingChangeFlag == TRUE)
8517 {
8518 /* apply setting */
8519 HAL_AUDIO_Pcm_HwDma_Reader1_Apply_Setting();
8520
8521 /* restart */
8522 HAL_AUDIO_Pcm_HwDma_Reader1_Restart();
8523 }
8524
8525 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0001);
8526 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0100);
8527
8528 pPcmInfo->u8StartFlag = TRUE;
8529 }
8530
8531 return s32Ret;
8532 }
8533
HAL_AUDIO_Pcm_HwDma_Reader1_Stop(void)8534 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Stop(void)
8535 {
8536 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8537 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8538 MS_S32 s32Ret = 0;
8539 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
8540
8541 if (pPcmInfo->u8StartFlag != FALSE)
8542 {
8543 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0000);
8544 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0000);
8545
8546 pPcmInfo->u8StartFlag = FALSE;
8547 }
8548
8549 return s32Ret;
8550 }
8551
HAL_AUDIO_Pcm_HwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)8552 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
8553 {
8554 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8555 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8556 MS_S32 s32Ret = 0;
8557 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
8558
8559 if (pData == NULL)
8560 {
8561 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
8562 return -A_EFAULT;
8563 }
8564
8565 if (pPcmInfo->u8ConnectFlag == FALSE)
8566 {
8567 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8568 return -A_EPERM;
8569 }
8570
8571 if (pPcmInfo->u8StartFlag != FALSE)
8572 {
8573 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
8574 return -A_EBUSY;
8575 }
8576
8577 switch(u32Cmd)
8578 {
8579 case AUDIO_PCM_CMD_NONBLOCKING:
8580 {
8581 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
8582
8583 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
8584 {
8585 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
8586 s32Ret = -A_EINVAL;
8587 break;
8588 }
8589
8590 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
8591
8592 break;
8593 }
8594
8595 case AUDIO_PCM_CMD_MULTICH:
8596 {
8597 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
8598
8599 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
8600 {
8601 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
8602 s32Ret = -A_EINVAL;
8603 break;
8604 }
8605
8606 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
8607 {
8608 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
8609 s32Ret = -A_EINVAL;
8610 break;
8611 }
8612
8613 pPcmInfo->u8MultiChFlag = FALSE;
8614
8615 break;
8616 }
8617
8618 case AUDIO_PCM_CMD_MIXING:
8619 {
8620 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
8621
8622 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
8623 {
8624 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
8625 s32Ret = -A_EINVAL;
8626 break;
8627 }
8628
8629 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
8630 {
8631 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
8632 s32Ret = -A_EINVAL;
8633 break;
8634 }
8635
8636 pPcmInfo->u8MixingFlag = FALSE;
8637
8638 break;
8639 }
8640
8641 case AUDIO_PCM_CMD_MIXINGGROUP:
8642 {
8643 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
8644
8645 pPcmInfo->u32MixingGroup = u32MixingGroup;
8646
8647 break;
8648 }
8649
8650 case AUDIO_PCM_CMD_BUFFERDURATION:
8651 {
8652 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
8653
8654 if (u32BufferDuration == 0)
8655 {
8656 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
8657 s32Ret = -A_EINVAL;
8658 break;
8659 }
8660
8661 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
8662 {
8663 pPcmInfo->u32BufferDuration = u32BufferDuration;
8664 pPCM->u8SettingChangeFlag = TRUE;
8665 }
8666
8667 break;
8668 }
8669
8670 case AUDIO_PCM_CMD_CHANNEL:
8671 {
8672 MS_U32 u32Channel = *((MS_U32 *)pData);
8673
8674 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
8675 {
8676 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
8677 return -A_EINVAL;
8678 }
8679
8680 pPcmInfo->u32Channel = u32Channel;
8681
8682 break;
8683 }
8684
8685 case AUDIO_PCM_CMD_SAMPLERATE:
8686 {
8687 MS_U32 u32SampleRate = *((MS_U32 *)pData);
8688
8689 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
8690 {
8691 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
8692 return -A_EINVAL;
8693 }
8694
8695 if (pPcmInfo->u32SampleRate != u32SampleRate)
8696 {
8697 pPcmInfo->u32SampleRate = u32SampleRate;
8698 pPCM->u8SettingChangeFlag = TRUE;
8699 }
8700
8701 break;
8702 }
8703
8704 case AUDIO_PCM_CMD_BITWIDTH:
8705 {
8706 MS_U32 u32BitWidth = *((MS_U32 *)pData);
8707
8708 pPcmInfo->u32BitWidth = u32BitWidth;
8709
8710 break;
8711 }
8712
8713 case AUDIO_PCM_CMD_BIGENDIEN:
8714 {
8715 MS_U32 u32BigEndien = *((MS_U32 *)pData);
8716
8717 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
8718 {
8719 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
8720 return -A_EINVAL;
8721 }
8722
8723 pPcmInfo->u32BigEndien = u32BigEndien;
8724
8725 break;
8726 }
8727
8728 case AUDIO_PCM_CMD_TIMESTAMP:
8729 {
8730 MS_U32 u32Timestamp = *((MS_U32 *)pData);
8731
8732 pPcmInfo->u32Timestamp = u32Timestamp;
8733
8734 break;
8735 }
8736
8737 case AUDIO_PCM_CMD_WEIGHTING:
8738 {
8739 MS_U32 u32Weighting = *((MS_U32 *)pData);
8740
8741 pPcmInfo->u32Weighting = u32Weighting;
8742
8743 break;
8744 }
8745
8746 case AUDIO_PCM_CMD_VOLUME:
8747 {
8748 MS_U32 u32Volume = *((MS_U32 *)pData);
8749
8750 pPcmInfo->u32Volume = u32Volume;
8751
8752 break;
8753 }
8754
8755 case AUDIO_PCM_CMD_MUTE:
8756 {
8757 MS_U32 u32Mute = *((MS_U32*)pData);
8758
8759 if (u32Mute == TRUE)
8760 {
8761 pPcmInfo->u32Volume |= 0x80000000;
8762 }
8763 else if (u32Mute == FALSE)
8764 {
8765 pPcmInfo->u32Volume &= 0x7FFFFFFF;
8766 }
8767 else
8768 {
8769 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
8770 s32Ret = -A_EINVAL;
8771 }
8772 break;
8773 }
8774
8775 default:
8776 {
8777 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
8778 break;
8779 }
8780 }
8781
8782 return s32Ret;
8783 }
8784
HAL_AUDIO_Pcm_HwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)8785 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
8786 {
8787 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8788 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8789 MS_S32 s32Ret = 0;
8790 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
8791
8792 if (pData == NULL)
8793 {
8794 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
8795 return -A_EFAULT;
8796 }
8797
8798 if (pPcmInfo->u8ConnectFlag == FALSE)
8799 {
8800 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8801 return -A_EPERM;
8802 }
8803
8804 switch(u32Cmd)
8805 {
8806 case AUDIO_PCM_CMD_ALL:
8807 {
8808 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
8809
8810 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
8811 {
8812 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
8813 s32Ret = -A_EINVAL;
8814 break;
8815 }
8816
8817 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
8818 {
8819 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
8820 s32Ret = -A_EINVAL;
8821 break;
8822 }
8823
8824 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
8825
8826 break;
8827 }
8828
8829 case AUDIO_PCM_CMD_NONBLOCKING:
8830 {
8831 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
8832 break;
8833 }
8834
8835 case AUDIO_PCM_CMD_MULTICH:
8836 {
8837 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
8838 break;
8839 }
8840
8841 case AUDIO_PCM_CMD_MIXING:
8842 {
8843 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
8844 break;
8845 }
8846
8847 case AUDIO_PCM_CMD_MIXINGGROUP:
8848 {
8849 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
8850 break;
8851 }
8852
8853 case AUDIO_PCM_CMD_BUFFER:
8854 {
8855 /*
8856 * TODO, need better coding
8857 *
8858 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
8859 */
8860 break;
8861 }
8862
8863 case AUDIO_PCM_CMD_BUFFERDURATION:
8864 {
8865 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
8866 break;
8867 }
8868
8869 case AUDIO_PCM_CMD_READPTR:
8870 {
8871 /*
8872 * TODO, need better coding
8873 *
8874 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
8875 */
8876 break;
8877 }
8878
8879 case AUDIO_PCM_CMD_WRITEPTR:
8880 {
8881 /*
8882 * TODO, need better coding
8883 *
8884 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
8885 */
8886 break;
8887 }
8888
8889 case AUDIO_PCM_CMD_CHANNEL:
8890 {
8891 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
8892 break;
8893 }
8894
8895 case AUDIO_PCM_CMD_SAMPLERATE:
8896 {
8897 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
8898 break;
8899 }
8900
8901 case AUDIO_PCM_CMD_BITWIDTH:
8902 {
8903 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
8904 break;
8905 }
8906
8907 case AUDIO_PCM_CMD_BIGENDIEN:
8908 {
8909 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
8910 break;
8911 }
8912
8913 case AUDIO_PCM_CMD_TIMESTAMP:
8914 {
8915 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
8916 break;
8917 }
8918
8919 case AUDIO_PCM_CMD_WEIGHTING:
8920 {
8921 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
8922 break;
8923 }
8924
8925 case AUDIO_PCM_CMD_VOLUME:
8926 {
8927 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
8928 break;
8929 }
8930
8931 case AUDIO_PCM_CMD_BUFFERLEVEL:
8932 {
8933 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0010);
8934 pPcmInfo->u32BufferLevel = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_6) * BYTES_IN_MIU_LINE) / 2;
8935 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0000);
8936 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
8937 break;
8938 }
8939
8940 case AUDIO_PCM_CMD_MUTE:
8941 {
8942 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
8943 break;
8944 }
8945
8946 default:
8947 {
8948 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
8949 break;
8950 }
8951 }
8952
8953 return s32Ret;
8954 }
8955
HAL_AUDIO_Pcm_HwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)8956 MS_U32 HAL_AUDIO_Pcm_HwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
8957 {
8958 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
8959 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
8960 MS_S8 *pBufTmp = NULL;
8961 MS_U32 u32BufferSize = 0;
8962 MS_U32 u32PcmLevel = 0;
8963 MS_U32 u32RequestSize = 0;
8964 MS_U32 u32RequestSampleCount = 0;
8965 MS_U32 u32TargetChannel = 0;
8966 MS_U32 u32Loop = 0;
8967 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
8968
8969 if (pBuf == NULL)
8970 {
8971 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
8972 return 0;
8973 }
8974
8975 if (u32Size == 0)
8976 {
8977 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
8978 return 0;
8979 }
8980
8981 if (pPcmInfo->u8ConnectFlag == FALSE)
8982 {
8983 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
8984 return 0;
8985 }
8986
8987 if (pPcmInfo->u8StartFlag == FALSE)
8988 {
8989 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
8990 return 0;
8991 }
8992
8993 pBufTmp = (MS_S8 *)pBuf;
8994
8995 HAL_AUDIO_Pcm_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
8996 u32PcmLevel = u32PcmLevel * 2;
8997 if ((u32PcmLevel / BYTES_IN_MIU_LINE) <= 6)
8998 {
8999 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
9000
9001 u32PcmLevel = 0;
9002 HAL_AUDIO_Pcm_HwDma_Reader1_Stop();
9003 HAL_AUDIO_Pcm_HwDma_Reader1_Restart();
9004 HAL_AUDIO_Pcm_HwDma_Reader1_Start();
9005 }
9006
9007 u32TargetChannel = 2;
9008 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2 * 2) / 1000;
9009 u32RequestSize = u32Size * 2;
9010 u32RequestSampleCount = u32Size / 2;
9011
9012 /* copy data to PCM buffer */
9013 if ((u32PcmLevel + u32RequestSize) < u32BufferSize)
9014 {
9015 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
9016 {
9017 *pPcmInfo->pWritePtr++ = 0;
9018 *pPcmInfo->pWritePtr++ = *pBufTmp++; /* L low, R low, L low, R low, ... */
9019 *pPcmInfo->pWritePtr++ = *pBufTmp++; /* L high, R high, L high, R high, ... */
9020 *pPcmInfo->pWritePtr++ = 0;
9021
9022 if (pPcmInfo->pWritePtr >= (pPcmInfo->pBuffer + u32BufferSize))
9023 {
9024 if (pPcmInfo->pWritePtr > (pPcmInfo->pBuffer + u32BufferSize))
9025 {
9026 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
9027 }
9028 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
9029 }
9030 }
9031
9032 /* flush MIU */
9033 MsOS_FlushMemory();
9034
9035 /* update copied size to engine */
9036 u32RequestSize += pPCM->u32RemainSize;
9037 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, (u32RequestSize/BYTES_IN_MIU_LINE));
9038 pPCM->u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
9039
9040 return u32Size;
9041 }
9042
9043 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
9044
9045 return 0;
9046 }
9047
HAL_AUDIO_Pcm_HwDma_Reader1_Flush(void)9048 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader1_Flush(void)
9049 {
9050 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9051 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9052 MS_S32 s32Ret = 0;
9053 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
9054
9055 if (pPcmInfo->u8StartFlag == FALSE)
9056 {
9057 HAL_AUDIO_Pcm_HwDma_Reader1_Restart();
9058 HAL_AUDIO_Pcm_HwDma_Reader1_Stop();
9059 }
9060
9061 return s32Ret;
9062 }
9063
HAL_AUDIO_Pcm_HwDma_Reader2_Apply_Setting(void)9064 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Apply_Setting(void)
9065 {
9066 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9067 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9068 MS_U16 u16Divisor = 0;
9069 MS_U16 u16Synthrate = 0;
9070 MS_U32 u32TargetBufferSize = 0;
9071 MS_U32 u32TargetChannel = 0;
9072 MS_S32 s32Ret = 0;
9073
9074 /*
9075 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
9076 */
9077 switch(pPcmInfo->u32SampleRate) {
9078 case 8000:
9079 {
9080 u16Divisor = 2;
9081 u16Synthrate = 0x6978;
9082 break;
9083 }
9084
9085 case 11025:
9086 {
9087 u16Divisor = 2;
9088 u16Synthrate = 0x4C87;
9089 break;
9090 }
9091
9092 case 12000:
9093 {
9094 u16Divisor = 2;
9095 u16Synthrate = 0x4650;
9096 break;
9097 }
9098
9099 case 16000:
9100 {
9101 u16Divisor = 1;
9102 u16Synthrate = 0x6978;
9103 break;
9104 }
9105
9106 case 22050:
9107 {
9108 u16Divisor = 1;
9109 u16Synthrate = 0x4C87;
9110 break;
9111 }
9112
9113 case 24000:
9114 {
9115 u16Divisor = 1;
9116 u16Synthrate = 0x4650;
9117 break;
9118 }
9119
9120 case 32000:
9121 {
9122 u16Divisor = 0;
9123 u16Synthrate = 0x6978;
9124 break;
9125 }
9126
9127 case 44100:
9128 {
9129 u16Divisor = 0;
9130 u16Synthrate = 0x4C87;
9131 break;
9132 }
9133
9134 case 48000:
9135 {
9136 u16Divisor = 0;
9137 u16Synthrate = 0x4650;
9138 break;
9139 }
9140
9141 default:
9142 {
9143 u16Divisor = 0;
9144 u16Synthrate = 0x4650;
9145 pPcmInfo->u32SampleRate = 48000;
9146 break;
9147 }
9148 }
9149
9150 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9151 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x030, (u16Divisor << 4));
9152 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Syth, 0xFFFF, u16Synthrate);
9153
9154 /* enable DMA synthesizer */
9155 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x145, 0x145);
9156
9157 /* calculate buffer size */
9158 u32TargetChannel = 2;
9159 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
9160 if (u32TargetBufferSize > HW_DMA_RDR1_BUF_SIZE)
9161 {
9162 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);
9163 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE;
9164 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * 2));
9165 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
9166 }
9167
9168 /* set buffer size */
9169 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9170
9171 /* set overrun & underrun threshold */
9172 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x0012);
9173
9174 pPCM->u8SettingChangeFlag = FALSE;
9175
9176 return s32Ret;
9177 }
9178
HAL_AUDIO_Pcm_HwDma_Reader2_Restart(void)9179 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Restart(void)
9180 {
9181 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9182 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9183 MS_S32 s32Ret = 0;
9184
9185 if (pPcmInfo->u8ConnectFlag == FALSE)
9186 {
9187 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9188 return -A_EPERM;
9189 }
9190
9191 /* clear PCM buffer */
9192 memset((void *)pPcmInfo->pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
9193
9194 /* flush MIU */
9195 MsOS_FlushMemory();
9196
9197 /* clear engine's write pointer */
9198 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x0000);
9199
9200 /* reset & start engine */
9201 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
9202 AUDIO_DELAY1MS(1);
9203 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
9204
9205 /* reset write pointer */
9206 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
9207
9208 /* reset remain size */
9209 pPCM->u32RemainSize = 0;
9210
9211 return s32Ret;
9212 }
9213
HAL_AUDIO_Pcm_HwDma_Reader2_Init(void * pData)9214 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Init(void *pData)
9215 {
9216 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9217 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9218 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
9219 MS_U32 u32TargetBufferAddrPa = 0;
9220 MS_U32 u32TargetBufferSize = 0;
9221 MS_U32 u32TargetChannel = 0;
9222 MS_S32 s32Ret = 0;
9223 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
9224
9225 if (pData == NULL)
9226 {
9227 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9228 return -A_EFAULT;
9229 }
9230
9231 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9232
9233 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
9234 {
9235 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9236 return -A_EINVAL;
9237 }
9238
9239 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9240 {
9241 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
9242 return -A_EINVAL;
9243 }
9244
9245 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9246 {
9247 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9248 return -A_EINVAL;
9249 }
9250
9251 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9252 {
9253 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
9254 return -A_EINVAL;
9255 }
9256
9257 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)
9258 {
9259 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
9260 return -A_EINVAL;
9261 }
9262
9263 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)
9264 {
9265 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
9266 return -A_EINVAL;
9267 }
9268
9269 u32TargetChannel = 2;
9270 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
9271 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
9272 {
9273 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);
9274 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
9275 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * 2));
9276 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
9277 }
9278
9279 /* fill in settings */
9280 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9281 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
9282 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
9283 pPcmInfo->u8ConnectFlag = TRUE;
9284 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
9285 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
9286
9287 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
9288 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
9289 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
9290 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
9291 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
9292 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
9293 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
9294 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
9295 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
9296 HAL_AUDIO_Pcm_HwDma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
9297
9298 /* init PCM buffer address */
9299 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR2_BUF_ADDR;
9300 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
9301 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
9302 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
9303
9304 /* set PCM buffer address */
9305 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Lo, 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* RD_BASE_ADDR[15:0] */
9306 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Hi, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16) & 0xFFFF)); /* RD_BASE_ADDR[31:15] */
9307
9308 /* set SEL_CLK_DMA_READER */
9309 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
9310 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x90 ); //CH8 sel to DMA Rdr
9311 HAL_AUDIO_AbsWriteReg(NewDMAreader_ctrl, 0x0);
9312
9313 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
9314 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x145, 0x145); //enable DMA synthesizer
9315
9316 /* apply setting */
9317 HAL_AUDIO_Pcm_HwDma_Reader2_Apply_Setting();
9318
9319 /* restart */
9320 HAL_AUDIO_Pcm_HwDma_Reader2_Restart();
9321
9322 return s32Ret;
9323 }
9324
HAL_AUDIO_Pcm_HwDma_Reader2_Exit(void)9325 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Exit(void)
9326 {
9327 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9328 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9329 MS_S32 s32Ret = 0;
9330 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
9331
9332 if (pPcmInfo->u8ConnectFlag != FALSE)
9333 {
9334 HAL_AUDIO_Pcm_HwDma_Reader2_Flush();
9335 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9336 }
9337
9338 return s32Ret;
9339 }
9340
HAL_AUDIO_Pcm_HwDma_Reader2_Start(void)9341 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Start(void)
9342 {
9343 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9344 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9345 MS_S32 s32Ret = 0;
9346 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
9347
9348 if (pPcmInfo->u8StartFlag == FALSE)
9349 {
9350 if (pPCM->u8SettingChangeFlag == TRUE)
9351 {
9352 /* apply setting */
9353 HAL_AUDIO_Pcm_HwDma_Reader2_Apply_Setting();
9354
9355 /* restart */
9356 HAL_AUDIO_Pcm_HwDma_Reader2_Restart();
9357 }
9358
9359 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0001);
9360 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0002);
9361
9362 pPcmInfo->u8StartFlag = TRUE;
9363 }
9364
9365 return s32Ret;
9366 }
9367
HAL_AUDIO_Pcm_HwDma_Reader2_Stop(void)9368 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Stop(void)
9369 {
9370 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9371 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9372 MS_S32 s32Ret = 0;
9373 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
9374
9375 if (pPcmInfo->u8StartFlag != FALSE)
9376 {
9377 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0000);
9378 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0000);
9379
9380 pPcmInfo->u8StartFlag = FALSE;
9381 }
9382
9383 return s32Ret;
9384 }
9385
HAL_AUDIO_Pcm_HwDma_Reader2_Set(MS_U32 u32Cmd,const void * pData)9386 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
9387 {
9388 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9389 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9390 MS_S32 s32Ret = 0;
9391 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9392
9393 if (pData == NULL)
9394 {
9395 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9396 return -A_EFAULT;
9397 }
9398
9399 if (pPcmInfo->u8ConnectFlag == FALSE)
9400 {
9401 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9402 return -A_EPERM;
9403 }
9404
9405 if (pPcmInfo->u8StartFlag != FALSE)
9406 {
9407 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
9408 return -A_EBUSY;
9409 }
9410
9411 switch(u32Cmd)
9412 {
9413 case AUDIO_PCM_CMD_NONBLOCKING:
9414 {
9415 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
9416
9417 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
9418 {
9419 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
9420 s32Ret = -A_EINVAL;
9421 break;
9422 }
9423
9424 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
9425
9426 break;
9427 }
9428
9429 case AUDIO_PCM_CMD_MULTICH:
9430 {
9431 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
9432
9433 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
9434 {
9435 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
9436 s32Ret = -A_EINVAL;
9437 break;
9438 }
9439
9440 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9441 {
9442 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9443 s32Ret = -A_EINVAL;
9444 break;
9445 }
9446
9447 pPcmInfo->u8MultiChFlag = FALSE;
9448
9449 break;
9450 }
9451
9452 case AUDIO_PCM_CMD_MIXING:
9453 {
9454 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
9455
9456 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
9457 {
9458 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
9459 s32Ret = -A_EINVAL;
9460 break;
9461 }
9462
9463 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9464 {
9465 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
9466 s32Ret = -A_EINVAL;
9467 break;
9468 }
9469
9470 pPcmInfo->u8MixingFlag = FALSE;
9471
9472 break;
9473 }
9474
9475 case AUDIO_PCM_CMD_MIXINGGROUP:
9476 {
9477 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
9478
9479 pPcmInfo->u32MixingGroup = u32MixingGroup;
9480
9481 break;
9482 }
9483
9484 case AUDIO_PCM_CMD_BUFFERDURATION:
9485 {
9486 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
9487
9488 if (u32BufferDuration == 0)
9489 {
9490 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
9491 s32Ret = -A_EINVAL;
9492 break;
9493 }
9494
9495 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
9496 {
9497 pPcmInfo->u32BufferDuration = u32BufferDuration;
9498 pPCM->u8SettingChangeFlag = TRUE;
9499 }
9500
9501 break;
9502 }
9503
9504 case AUDIO_PCM_CMD_CHANNEL:
9505 {
9506 MS_U32 u32Channel = *((MS_U32 *)pData);
9507
9508 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9509 {
9510 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
9511 return -A_EINVAL;
9512 }
9513
9514 pPcmInfo->u32Channel = u32Channel;
9515
9516 break;
9517 }
9518
9519 case AUDIO_PCM_CMD_SAMPLERATE:
9520 {
9521 MS_U32 u32SampleRate = *((MS_U32 *)pData);
9522
9523 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9524 {
9525 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
9526 return -A_EINVAL;
9527 }
9528
9529 if (pPcmInfo->u32SampleRate != u32SampleRate)
9530 {
9531 pPcmInfo->u32SampleRate = u32SampleRate;
9532 pPCM->u8SettingChangeFlag = TRUE;
9533 }
9534
9535 break;
9536 }
9537
9538 case AUDIO_PCM_CMD_BITWIDTH:
9539 {
9540 MS_U32 u32BitWidth = *((MS_U32 *)pData);
9541
9542 pPcmInfo->u32BitWidth = u32BitWidth;
9543
9544 break;
9545 }
9546
9547 case AUDIO_PCM_CMD_BIGENDIEN:
9548 {
9549 MS_U32 u32BigEndien = *((MS_U32 *)pData);
9550
9551 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
9552 {
9553 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
9554 return -A_EINVAL;
9555 }
9556
9557 pPcmInfo->u32BigEndien = u32BigEndien;
9558
9559 break;
9560 }
9561
9562 case AUDIO_PCM_CMD_TIMESTAMP:
9563 {
9564 MS_U32 u32Timestamp = *((MS_U32 *)pData);
9565
9566 pPcmInfo->u32Timestamp = u32Timestamp;
9567
9568 break;
9569 }
9570
9571 case AUDIO_PCM_CMD_WEIGHTING:
9572 {
9573 MS_U32 u32Weighting = *((MS_U32 *)pData);
9574
9575 pPcmInfo->u32Weighting = u32Weighting;
9576
9577 break;
9578 }
9579
9580 case AUDIO_PCM_CMD_VOLUME:
9581 {
9582 MS_U32 u32Volume = *((MS_U32 *)pData);
9583
9584 pPcmInfo->u32Volume = u32Volume;
9585
9586 break;
9587 }
9588
9589 case AUDIO_PCM_CMD_MUTE:
9590 {
9591 MS_U32 u32Mute = *((MS_U32*)pData);
9592
9593 if (u32Mute == TRUE)
9594 {
9595 pPcmInfo->u32Volume |= 0x80000000;
9596 }
9597 else if (u32Mute == FALSE)
9598 {
9599 pPcmInfo->u32Volume &= 0x7FFFFFFF;
9600 }
9601 else
9602 {
9603 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
9604 s32Ret = -A_EINVAL;
9605 }
9606 break;
9607 }
9608
9609 default:
9610 {
9611 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
9612 break;
9613 }
9614 }
9615
9616 return s32Ret;
9617 }
9618
HAL_AUDIO_Pcm_HwDma_Reader2_Get(MS_U32 u32Cmd,void * pData)9619 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Get(MS_U32 u32Cmd, void *pData)
9620 {
9621 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9622 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9623 MS_S32 s32Ret = 0;
9624 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9625
9626 if (pData == NULL)
9627 {
9628 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
9629 return -A_EFAULT;
9630 }
9631
9632 if (pPcmInfo->u8ConnectFlag == FALSE)
9633 {
9634 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9635 return -A_EPERM;
9636 }
9637
9638 switch(u32Cmd)
9639 {
9640 case AUDIO_PCM_CMD_ALL:
9641 {
9642 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9643
9644 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
9645 {
9646 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9647 s32Ret = -A_EINVAL;
9648 break;
9649 }
9650
9651 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9652 {
9653 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
9654 s32Ret = -A_EINVAL;
9655 break;
9656 }
9657
9658 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
9659
9660 break;
9661 }
9662
9663 case AUDIO_PCM_CMD_NONBLOCKING:
9664 {
9665 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
9666 break;
9667 }
9668
9669 case AUDIO_PCM_CMD_MULTICH:
9670 {
9671 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
9672 break;
9673 }
9674
9675 case AUDIO_PCM_CMD_MIXING:
9676 {
9677 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
9678 break;
9679 }
9680
9681 case AUDIO_PCM_CMD_MIXINGGROUP:
9682 {
9683 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
9684 break;
9685 }
9686
9687 case AUDIO_PCM_CMD_BUFFER:
9688 {
9689 /*
9690 * TODO, need better coding
9691 *
9692 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
9693 */
9694 break;
9695 }
9696
9697 case AUDIO_PCM_CMD_BUFFERDURATION:
9698 {
9699 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
9700 break;
9701 }
9702
9703 case AUDIO_PCM_CMD_READPTR:
9704 {
9705 /*
9706 * TODO, need better coding
9707 *
9708 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
9709 */
9710 break;
9711 }
9712
9713 case AUDIO_PCM_CMD_WRITEPTR:
9714 {
9715 /*
9716 * TODO, need better coding
9717 *
9718 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
9719 */
9720 break;
9721 }
9722
9723 case AUDIO_PCM_CMD_CHANNEL:
9724 {
9725 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
9726 break;
9727 }
9728
9729 case AUDIO_PCM_CMD_SAMPLERATE:
9730 {
9731 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
9732 break;
9733 }
9734
9735 case AUDIO_PCM_CMD_BITWIDTH:
9736 {
9737 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
9738 break;
9739 }
9740
9741 case AUDIO_PCM_CMD_BIGENDIEN:
9742 {
9743 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
9744 break;
9745 }
9746
9747 case AUDIO_PCM_CMD_TIMESTAMP:
9748 {
9749 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
9750 break;
9751 }
9752
9753 case AUDIO_PCM_CMD_WEIGHTING:
9754 {
9755 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
9756 break;
9757 }
9758
9759 case AUDIO_PCM_CMD_VOLUME:
9760 {
9761 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
9762 break;
9763 }
9764
9765 case AUDIO_PCM_CMD_BUFFERLEVEL:
9766 {
9767 MS_U16 DRAM_levelcnt1 = 0, DRAM_levelcnt2 = 0;
9768 MS_U16 time_out = 0;
9769
9770 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt);
9771 DRAM_levelcnt2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt);
9772 while ((DRAM_levelcnt1 != DRAM_levelcnt2) && (time_out++<2000))
9773 {
9774 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt);
9775 DRAM_levelcnt2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt);
9776 }
9777 pPcmInfo->u32BufferLevel = DRAM_levelcnt1 * BYTES_IN_MIU_LINE;
9778 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
9779 break;
9780 }
9781
9782 case AUDIO_PCM_CMD_MUTE:
9783 {
9784 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
9785 break;
9786 }
9787
9788 default:
9789 {
9790 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
9791 break;
9792 }
9793 }
9794
9795 return s32Ret;
9796 }
9797
HAL_AUDIO_Pcm_HwDma_Reader2_Write(const void * pBuf,MS_U32 u32Size)9798 MS_U32 HAL_AUDIO_Pcm_HwDma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
9799 {
9800 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9801 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9802 MS_S8 *pBufTmp = NULL;
9803 MS_U32 u32BufferSize = 0;
9804 MS_U32 u32PcmLevel = 0;
9805 MS_U32 u32RequestSize = 0;
9806 MS_U32 u32RequestSampleCount = 0;
9807 MS_U32 u32TargetChannel = 0;
9808 MS_U32 u32Loop = 0;
9809 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
9810
9811 if (pBuf == NULL)
9812 {
9813 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
9814 return 0;
9815 }
9816
9817 if (u32Size == 0)
9818 {
9819 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
9820 return 0;
9821 }
9822
9823 if (pPcmInfo->u8ConnectFlag == FALSE)
9824 {
9825 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
9826 return 0;
9827 }
9828
9829 if (pPcmInfo->u8StartFlag == FALSE)
9830 {
9831 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
9832 return 0;
9833 }
9834
9835 pBufTmp = (MS_S8 *)pBuf;
9836
9837 HAL_AUDIO_Pcm_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
9838
9839 u32TargetChannel = 2;
9840 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
9841 u32RequestSize = u32Size;
9842 u32RequestSampleCount = u32Size / u32TargetChannel / 2;
9843
9844 //printf("u32PcmLevel: %x u32RequestSize: %x u32BufferSize: %x\n", u32PcmLevel, u32RequestSize, u32BufferSize);
9845 /* copy data to PCM buffer */
9846 if ((u32PcmLevel + u32RequestSize) < u32BufferSize)
9847 {
9848 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
9849 {
9850 *pPcmInfo->pWritePtr++ = *pBufTmp++;
9851 *pPcmInfo->pWritePtr++ = *pBufTmp++;
9852 *pPcmInfo->pWritePtr++ = *pBufTmp++;
9853 *pPcmInfo->pWritePtr++ = *pBufTmp++;
9854 if (pPcmInfo->pWritePtr >= (pPcmInfo->pBuffer + u32BufferSize))
9855 {
9856 if (pPcmInfo->pWritePtr > (pPcmInfo->pBuffer + u32BufferSize))
9857 {
9858 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
9859 }
9860 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
9861 }
9862 }
9863
9864 /* flush MIU */
9865 MsOS_FlushMemory();
9866
9867 /* update copied size to engine */
9868 u32RequestSize += pPCM->u32RemainSize;
9869 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
9870 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0000);
9871 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0010);
9872 pPCM->u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
9873
9874 return u32Size;
9875 }
9876
9877 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
9878
9879 return 0;
9880 }
9881
HAL_AUDIO_Pcm_HwDma_Reader2_Flush(void)9882 MS_S32 HAL_AUDIO_Pcm_HwDma_Reader2_Flush(void)
9883 {
9884 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
9885 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9886 MS_S32 s32Ret = 0;
9887 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
9888
9889 if (pPcmInfo->u8StartFlag == FALSE)
9890 {
9891 HAL_AUDIO_Pcm_HwDma_Reader2_Restart();
9892 HAL_AUDIO_Pcm_HwDma_Reader2_Stop();
9893 }
9894
9895 return s32Ret;
9896 }
9897
HAL_AUDIO_Pcm_SwDma_Reader1_Apply_Setting(void)9898 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Apply_Setting(void)
9899 {
9900 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
9901 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
9902 MS_U16 u16Synthrate_H = 0;
9903 MS_U16 u16Synthrate_L = 0;
9904 MS_U32 u32TargetBufferSize = 0;
9905 MS_U32 u32TargetChannel = 0;
9906 MS_S32 s32Ret = 0;
9907
9908 switch(pPcmInfo->u32SampleRate) {
9909 case 8000:
9910 {
9911 u16Synthrate_H = 0x6978;
9912 u16Synthrate_L = 0x0000;
9913 break;
9914 }
9915
9916 case 11025:
9917 {
9918 u16Synthrate_H = 0x4C87;
9919 u16Synthrate_L = 0xD634;
9920 break;
9921 }
9922
9923 case 12000:
9924 {
9925 u16Synthrate_H = 0x4650;
9926 u16Synthrate_L = 0x0000;
9927 break;
9928 }
9929
9930 case 16000:
9931 {
9932 u16Synthrate_H = 0x34BC;
9933 u16Synthrate_L = 0x0000;
9934 break;
9935 }
9936
9937 case 22050:
9938 {
9939 u16Synthrate_H = 0x2643;
9940 u16Synthrate_L = 0xEB1A;
9941 break;
9942 }
9943
9944 case 24000:
9945 {
9946 u16Synthrate_H = 0x2328;
9947 u16Synthrate_L = 0x0000;
9948 break;
9949 }
9950
9951 case 32000:
9952 {
9953 u16Synthrate_H = 0x1A5E;
9954 u16Synthrate_L = 0x0000;
9955 break;
9956 }
9957
9958 case 44100:
9959 {
9960 u16Synthrate_H = 0x1321;
9961 u16Synthrate_L = 0xF58D;
9962 break;
9963 }
9964
9965 case 48000:
9966 {
9967 u16Synthrate_H = 0x1194;
9968 u16Synthrate_L = 0x0000;
9969 break;
9970 }
9971
9972 case 96000:
9973 {
9974 u16Synthrate_H = 0x08CA;
9975 u16Synthrate_L = 0x0000;
9976 break;
9977 }
9978
9979 default:
9980 {
9981 u16Synthrate_H = 0x1194;
9982 u16Synthrate_L = 0x0000;
9983 pPcmInfo->u32SampleRate = 48000;
9984 break;
9985 }
9986 }
9987
9988 /* enable reg_dvb5_fix_synth_nf_h */
9989 HAL_AUDIO_WriteMaskReg(0x2C24, 0xA000, 0xA000);
9990
9991 /* configure sample rate */
9992 HAL_AUDIO_WriteMaskReg(0x2C26, 0xFFFF, u16Synthrate_H);
9993 HAL_AUDIO_WriteMaskReg(0x2C28, 0xFFFF, u16Synthrate_L);
9994
9995 /* trigger reg_dvb5_fix_synth_nf_h to apply configuration */
9996 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x1000);
9997 AUDIO_DELAY1MS(1);
9998 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x0000);
9999
10000 /* calculate buffer size */
10001 u32TargetChannel = 2;
10002 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
10003 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10004 {
10005 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);
10006 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10007 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * 2));
10008 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
10009 }
10010
10011 pPCM->u8SettingChangeFlag = FALSE;
10012
10013 return s32Ret;
10014 }
10015
HAL_AUDIO_Pcm_SwDma_Reader1_Restart(void)10016 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Restart(void)
10017 {
10018 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10019 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10020 MS_S32 s32Ret = 0;
10021
10022 if (pPcmInfo->u8ConnectFlag == FALSE)
10023 {
10024 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10025 return -A_EPERM;
10026 }
10027
10028 /* clear PCM buffer */
10029 memset((void *)pPcmInfo->pBuffer, 0x00, SW_DMA_RDR1_BUF_SIZE);
10030
10031 /* flush MIU */
10032 MsOS_FlushMemory();
10033
10034 /* clear engine's write pointer */
10035 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, 0x0000);
10036
10037 /* reset engine, no start engine here! */
10038 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0001);
10039
10040 /* reset write pointer */
10041 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
10042
10043 /* reset remain size */
10044 pPCM->u32RemainSize = 0;
10045
10046 return s32Ret;
10047 }
10048
HAL_AUDIO_Pcm_SwDma_Reader1_Init(void * pData)10049 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Init(void *pData)
10050 {
10051 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10052 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10053 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10054 MS_U32 u32TargetBufferAddrPa = 0;
10055 MS_U32 u32TargetBufferSize = 0;
10056 MS_U32 u32TargetChannel = 0;
10057 MS_S32 s32Ret = 0;
10058 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10059
10060 if (pData == NULL)
10061 {
10062 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10063 return -A_EFAULT;
10064 }
10065
10066 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10067
10068 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
10069 {
10070 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10071 return -A_EINVAL;
10072 }
10073
10074 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10075 {
10076 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
10077 return -A_EINVAL;
10078 }
10079
10080 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10081 {
10082 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10083 return -A_EINVAL;
10084 }
10085
10086 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10087 {
10088 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10089 return -A_EINVAL;
10090 }
10091
10092 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)
10093 {
10094 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
10095 return -A_EINVAL;
10096 }
10097
10098 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)
10099 {
10100 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
10101 return -A_EINVAL;
10102 }
10103
10104 u32TargetChannel = 2;
10105 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
10106 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
10107 {
10108 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);
10109 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
10110 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * 2));
10111 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
10112 }
10113
10114 /* fill in settings */
10115 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10116 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10117 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10118 pPcmInfo->u8ConnectFlag = TRUE;
10119 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
10120 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
10121 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10122 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10123 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10124 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10125 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10126 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10127 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10128 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
10129 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10130 HAL_AUDIO_Pcm_SwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10131
10132 /* init PCM buffer address */
10133 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + SW_DMA_RDR1_BUF_ADDR;
10134 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10135 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
10136 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
10137
10138 /* apply setting */
10139 HAL_AUDIO_Pcm_SwDma_Reader1_Apply_Setting();
10140
10141 /* restart */
10142 HAL_AUDIO_Pcm_SwDma_Reader1_Restart();
10143
10144 return s32Ret;
10145 }
10146
HAL_AUDIO_Pcm_SwDma_Reader1_Exit(void)10147 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Exit(void)
10148 {
10149 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10150 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10151 MS_S32 s32Ret = 0;
10152 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10153
10154 if (pPcmInfo->u8ConnectFlag != FALSE)
10155 {
10156 HAL_AUDIO_Pcm_SwDma_Reader1_Flush();
10157 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10158 }
10159
10160 return s32Ret;
10161 }
10162
HAL_AUDIO_Pcm_SwDma_Reader1_Start(void)10163 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Start(void)
10164 {
10165 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10166 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10167 MS_S32 s32Ret = 0;
10168 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10169
10170 if (pPcmInfo->u8StartFlag == FALSE)
10171 {
10172 if (pPCM->u8SettingChangeFlag == TRUE)
10173 {
10174 /* apply setting */
10175 HAL_AUDIO_Pcm_SwDma_Reader1_Apply_Setting();
10176
10177 /* restart */
10178 HAL_AUDIO_Pcm_SwDma_Reader1_Restart();
10179 }
10180
10181 /* start engine */
10182 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0002);
10183
10184 pPcmInfo->u8StartFlag = TRUE;
10185 }
10186
10187 return s32Ret;
10188 }
10189
HAL_AUDIO_Pcm_SwDma_Reader1_Stop(void)10190 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Stop(void)
10191 {
10192 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10193 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10194 MS_S32 s32Ret = 0;
10195 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10196
10197 if (pPcmInfo->u8StartFlag != FALSE)
10198 {
10199 /* stop engine */
10200 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0000);
10201
10202 pPcmInfo->u8StartFlag = FALSE;
10203 }
10204
10205 return s32Ret;
10206 }
10207
HAL_AUDIO_Pcm_SwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)10208 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
10209 {
10210 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10211 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10212 MS_S32 s32Ret = 0;
10213 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10214
10215 if (pData == NULL)
10216 {
10217 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10218 return -A_EFAULT;
10219 }
10220
10221 if (pPcmInfo->u8ConnectFlag == FALSE)
10222 {
10223 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10224 return -A_EPERM;
10225 }
10226
10227 if (pPcmInfo->u8StartFlag != FALSE)
10228 {
10229 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
10230 return -A_EBUSY;
10231 }
10232
10233 switch(u32Cmd)
10234 {
10235 case AUDIO_PCM_CMD_NONBLOCKING:
10236 {
10237 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10238
10239 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10240 {
10241 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10242 s32Ret = -A_EINVAL;
10243 break;
10244 }
10245
10246 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10247
10248 break;
10249 }
10250
10251 case AUDIO_PCM_CMD_MULTICH:
10252 {
10253 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10254
10255 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10256 {
10257 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10258 s32Ret = -A_EINVAL;
10259 break;
10260 }
10261
10262 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10263 {
10264 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10265 s32Ret = -A_EINVAL;
10266 break;
10267 }
10268
10269 pPcmInfo->u8MultiChFlag = FALSE;
10270
10271 break;
10272 }
10273
10274 case AUDIO_PCM_CMD_MIXING:
10275 {
10276 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10277
10278 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10279 {
10280 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10281 s32Ret = -A_EINVAL;
10282 break;
10283 }
10284
10285 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10286 {
10287 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10288 s32Ret = -A_EINVAL;
10289 break;
10290 }
10291
10292 pPcmInfo->u8MixingFlag = FALSE;
10293
10294 break;
10295 }
10296
10297 case AUDIO_PCM_CMD_MIXINGGROUP:
10298 {
10299 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10300
10301 pPcmInfo->u32MixingGroup = u32MixingGroup;
10302
10303 break;
10304 }
10305
10306 case AUDIO_PCM_CMD_BUFFERDURATION:
10307 {
10308 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
10309
10310 if (u32BufferDuration == 0)
10311 {
10312 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
10313 s32Ret = -A_EINVAL;
10314 break;
10315 }
10316
10317 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
10318 {
10319 pPcmInfo->u32BufferDuration = u32BufferDuration;
10320 pPCM->u8SettingChangeFlag = TRUE;
10321 }
10322
10323 break;
10324 }
10325
10326 case AUDIO_PCM_CMD_CHANNEL:
10327 {
10328 MS_U32 u32Channel = *((MS_U32 *)pData);
10329
10330 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10331 {
10332 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
10333 return -A_EINVAL;
10334 }
10335
10336 pPcmInfo->u32Channel = u32Channel;
10337
10338 break;
10339 }
10340
10341 case AUDIO_PCM_CMD_SAMPLERATE:
10342 {
10343 MS_U32 u32SampleRate = *((MS_U32 *)pData);
10344
10345 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10346 {
10347 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
10348 return -A_EINVAL;
10349 }
10350
10351 if (pPcmInfo->u32SampleRate != u32SampleRate)
10352 {
10353 pPcmInfo->u32SampleRate = u32SampleRate;
10354 pPCM->u8SettingChangeFlag = TRUE;
10355 }
10356
10357 break;
10358 }
10359
10360 case AUDIO_PCM_CMD_BITWIDTH:
10361 {
10362 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10363
10364 pPcmInfo->u32BitWidth = u32BitWidth;
10365
10366 break;
10367 }
10368
10369 case AUDIO_PCM_CMD_BIGENDIEN:
10370 {
10371 MS_U32 u32BigEndien = *((MS_U32 *)pData);
10372
10373 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
10374 {
10375 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
10376 return -A_EINVAL;
10377 }
10378
10379 pPcmInfo->u32BigEndien = u32BigEndien;
10380
10381 break;
10382 }
10383
10384 case AUDIO_PCM_CMD_TIMESTAMP:
10385 {
10386 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10387
10388 pPcmInfo->u32Timestamp = u32Timestamp;
10389
10390 break;
10391 }
10392
10393 case AUDIO_PCM_CMD_WEIGHTING:
10394 {
10395 MS_U32 u32Weighting = *((MS_U32 *)pData);
10396
10397 pPcmInfo->u32Weighting = u32Weighting;
10398
10399 break;
10400 }
10401
10402 case AUDIO_PCM_CMD_VOLUME:
10403 {
10404 MS_U32 u32Volume = *((MS_U32 *)pData);
10405
10406 pPcmInfo->u32Volume = u32Volume;
10407
10408 break;
10409 }
10410
10411 case AUDIO_PCM_CMD_MUTE:
10412 {
10413 MS_U32 u32Mute = *((MS_U32*)pData);
10414
10415 if (u32Mute == TRUE)
10416 {
10417 pPcmInfo->u32Volume |= 0x80000000;
10418 }
10419 else if (u32Mute == FALSE)
10420 {
10421 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10422 }
10423 else
10424 {
10425 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
10426 s32Ret = -A_EINVAL;
10427 }
10428 break;
10429 }
10430
10431 default:
10432 {
10433 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10434 break;
10435 }
10436 }
10437
10438 return s32Ret;
10439 }
10440
HAL_AUDIO_Pcm_SwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)10441 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
10442 {
10443 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10444 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10445 MS_S32 s32Ret = 0;
10446 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10447
10448 if (pData == NULL)
10449 {
10450 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10451 return -A_EFAULT;
10452 }
10453
10454 if (pPcmInfo->u8ConnectFlag == FALSE)
10455 {
10456 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10457 return -A_EPERM;
10458 }
10459
10460 switch(u32Cmd)
10461 {
10462 case AUDIO_PCM_CMD_ALL:
10463 {
10464 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10465
10466 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
10467 {
10468 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10469 s32Ret = -A_EINVAL;
10470 break;
10471 }
10472
10473 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10474 {
10475 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
10476 s32Ret = -A_EINVAL;
10477 break;
10478 }
10479
10480 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
10481
10482 break;
10483 }
10484
10485 case AUDIO_PCM_CMD_NONBLOCKING:
10486 {
10487 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
10488 break;
10489 }
10490
10491 case AUDIO_PCM_CMD_MULTICH:
10492 {
10493 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
10494 break;
10495 }
10496
10497 case AUDIO_PCM_CMD_MIXING:
10498 {
10499 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
10500 break;
10501 }
10502
10503 case AUDIO_PCM_CMD_MIXINGGROUP:
10504 {
10505 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
10506 break;
10507 }
10508
10509 case AUDIO_PCM_CMD_BUFFER:
10510 {
10511 /*
10512 * TODO, need better coding
10513 *
10514 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
10515 */
10516 break;
10517 }
10518
10519 case AUDIO_PCM_CMD_BUFFERDURATION:
10520 {
10521 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
10522 break;
10523 }
10524
10525 case AUDIO_PCM_CMD_READPTR:
10526 {
10527 /*
10528 * TODO, need better coding
10529 *
10530 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
10531 */
10532 break;
10533 }
10534
10535 case AUDIO_PCM_CMD_WRITEPTR:
10536 {
10537 /*
10538 * TODO, need better coding
10539 *
10540 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
10541 */
10542 break;
10543 }
10544
10545 case AUDIO_PCM_CMD_CHANNEL:
10546 {
10547 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
10548 break;
10549 }
10550
10551 case AUDIO_PCM_CMD_SAMPLERATE:
10552 {
10553 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
10554 break;
10555 }
10556
10557 case AUDIO_PCM_CMD_BITWIDTH:
10558 {
10559 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10560 break;
10561 }
10562
10563 case AUDIO_PCM_CMD_BIGENDIEN:
10564 {
10565 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
10566 break;
10567 }
10568
10569 case AUDIO_PCM_CMD_TIMESTAMP:
10570 {
10571 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10572 break;
10573 }
10574
10575 case AUDIO_PCM_CMD_WEIGHTING:
10576 {
10577 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10578 break;
10579 }
10580
10581 case AUDIO_PCM_CMD_VOLUME:
10582 {
10583 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
10584 break;
10585 }
10586
10587 case AUDIO_PCM_CMD_BUFFERLEVEL:
10588 {
10589 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0008);
10590 pPcmInfo->u32BufferLevel = HAL_AUDIO_ReadReg(S2M_MBOX_SW_DMA_READER_DDR_Level) * BYTES_IN_MIU_LINE;
10591 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0000);
10592 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10593 break;
10594 }
10595
10596 case AUDIO_PCM_CMD_MUTE:
10597 {
10598 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10599 break;
10600 }
10601
10602 default:
10603 {
10604 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10605 break;
10606 }
10607 }
10608
10609 return s32Ret;
10610 }
10611
HAL_AUDIO_Pcm_SwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)10612 MS_U32 HAL_AUDIO_Pcm_SwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
10613 {
10614 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10615 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10616 MS_U8 *pBufTmp = NULL;
10617 MS_U32 u32BufferSize = 0;
10618 MS_U32 u32PcmLevel = 0;
10619 MS_U32 u32RequestSize = 0;
10620 MS_U32 u32RequestSizeTmp = 0;
10621 MS_U32 u32SizeToCopy = 0;
10622 MS_U32 u32WptrOffset = 0;
10623 MS_U32 u32TargetChannel = 0;
10624 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10625
10626 if (pBuf == NULL)
10627 {
10628 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10629 return 0;
10630 }
10631
10632 if (u32Size == 0)
10633 {
10634 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
10635 return 0;
10636 }
10637
10638 if (pPcmInfo->u8ConnectFlag == FALSE)
10639 {
10640 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10641 return 0;
10642 }
10643
10644 if (pPcmInfo->u8StartFlag == FALSE)
10645 {
10646 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
10647 return 0;
10648 }
10649
10650 pBufTmp = (MS_U8 *)pBuf;
10651
10652 HAL_AUDIO_Pcm_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10653 if (u32PcmLevel == 0)
10654 {
10655 HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10656 }
10657
10658 pBufTmp = (MS_U8 *)pBuf;
10659 u32RequestSize = u32Size;
10660 u32RequestSizeTmp = u32RequestSize;
10661
10662 u32TargetChannel = 2;
10663 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
10664
10665 if ((u32PcmLevel + u32RequestSize) < u32BufferSize)
10666 {
10667 do {
10668 u32SizeToCopy = (pPcmInfo->pBuffer + SW_DMA_RDR1_BUF_SIZE) - pPcmInfo->pWritePtr;
10669 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
10670
10671 memcpy((void *)pPcmInfo->pWritePtr, (void *)pBufTmp, u32SizeToCopy);
10672
10673 pBufTmp += u32SizeToCopy;
10674 pPcmInfo->pWritePtr += u32SizeToCopy;
10675 if (pPcmInfo->pWritePtr >= (pPcmInfo->pBuffer + SW_DMA_RDR1_BUF_SIZE))
10676 {
10677 if (pPcmInfo->pWritePtr > (pPcmInfo->pBuffer + SW_DMA_RDR1_BUF_SIZE))
10678 {
10679 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
10680 }
10681 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
10682 }
10683
10684 u32RequestSizeTmp -= u32SizeToCopy;
10685 } while (u32RequestSizeTmp > 0);
10686
10687 /* flush MIU */
10688 MsOS_FlushMemory();
10689
10690 /* update write pointers to engine */
10691 u32WptrOffset = pPcmInfo->pWritePtr - pPcmInfo->pBuffer;
10692 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, (u32WptrOffset / BYTES_IN_MIU_LINE));
10693
10694 return u32Size;
10695 }
10696
10697 //HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
10698
10699 return 0;
10700 }
10701
HAL_AUDIO_Pcm_SwDma_Reader1_Flush(void)10702 MS_S32 HAL_AUDIO_Pcm_SwDma_Reader1_Flush(void)
10703 {
10704 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
10705 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10706 MS_S32 s32Ret = 0;
10707 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
10708
10709 if (pPcmInfo->u8StartFlag == FALSE)
10710 {
10711 HAL_AUDIO_Pcm_SwDma_Reader1_Restart();
10712 HAL_AUDIO_Pcm_SwDma_Reader1_Stop();
10713 }
10714
10715 return s32Ret;
10716 }
10717
HAL_AUDIO_Pcm_Capture1_Restart(void)10718 MS_S32 HAL_AUDIO_Pcm_Capture1_Restart(void)
10719 {
10720 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10721 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10722 MS_U32 u32WritePtrOffset = 0;
10723 MS_U32 u32TimeoutCounter = 0;
10724 MS_S32 s32Ret = 0;
10725
10726 if (pPcmInfo->u8ConnectFlag == FALSE)
10727 {
10728 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10729 return -A_EPERM;
10730 }
10731
10732 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0x0000);
10733
10734 do {
10735 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
10736
10737 if (u32WritePtrOffset != 0)
10738 {
10739 AUDIO_DELAY1MS(1);
10740 u32TimeoutCounter++;
10741 }
10742 else
10743 {
10744 break;
10745 }
10746 } while (u32TimeoutCounter < 500);
10747
10748 /* clear PCM buffer */
10749 memset((void *)pPcmInfo->pBuffer, 0x00, PCM_CAPTURE1_BUF_SIZE);
10750
10751 /* flush MIU */
10752 MsOS_FlushMemory();
10753
10754 /* reset PCM capture1 read & write pointer */
10755 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
10756 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
10757 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0x0000);
10758
10759 return s32Ret;
10760 }
10761
HAL_AUDIO_Pcm_Capture1_Init(void * pData)10762 MS_S32 HAL_AUDIO_Pcm_Capture1_Init(void *pData)
10763 {
10764 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10765 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10766 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10767 MS_U32 u32TargetBufferAddrPa = 0;
10768 MS_S32 s32Ret = 0;
10769 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10770
10771 if (pData == NULL)
10772 {
10773 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10774 return -A_EFAULT;
10775 }
10776
10777 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10778
10779 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
10780 {
10781 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10782 return -A_EINVAL;
10783 }
10784
10785 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10786 {
10787 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
10788 return -A_EINVAL;
10789 }
10790
10791 if (pUserPcmInfo->u8MultiChFlag == TRUE)
10792 {
10793 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10794 return -A_EINVAL;
10795 }
10796
10797 if (pUserPcmInfo->u8MixingFlag == TRUE)
10798 {
10799 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10800 return -A_EINVAL;
10801 }
10802
10803 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)
10804 {
10805 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
10806 return -A_EINVAL;
10807 }
10808
10809 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)
10810 {
10811 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
10812 return -A_EINVAL;
10813 }
10814
10815 /* fill in settings */
10816 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10817 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10818 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10819 pPcmInfo->u8ConnectFlag = TRUE;
10820 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
10821 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
10822 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10823 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10824 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10825 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
10826 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10827 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10828 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10829 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
10830 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10831 HAL_AUDIO_Pcm_Capture1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10832
10833 /* init PCM buffer address */
10834 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
10835 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10836 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
10837 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
10838
10839 /* restart */
10840 HAL_AUDIO_Pcm_Capture1_Restart();
10841
10842 return s32Ret;
10843 }
10844
HAL_AUDIO_Pcm_Capture1_Exit(void)10845 MS_S32 HAL_AUDIO_Pcm_Capture1_Exit(void)
10846 {
10847 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10848 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10849 MS_S32 s32Ret = 0;
10850 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10851
10852 if (pPcmInfo->u8ConnectFlag != FALSE)
10853 {
10854 HAL_AUDIO_Pcm_Capture1_Flush();
10855 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10856 }
10857
10858 return s32Ret;
10859 }
10860
HAL_AUDIO_Pcm_Capture1_Start(void)10861 MS_S32 HAL_AUDIO_Pcm_Capture1_Start(void)
10862 {
10863 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10864 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10865 MS_U32 u32BufferSize = 0;
10866 MS_S32 s32Ret = 0;
10867 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10868
10869 if (pPcmInfo->u8StartFlag == FALSE)
10870 {
10871 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
10872 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
10873
10874 pPcmInfo->u8StartFlag = TRUE;
10875 }
10876
10877 return s32Ret;
10878 }
10879
HAL_AUDIO_Pcm_Capture1_Stop(void)10880 MS_S32 HAL_AUDIO_Pcm_Capture1_Stop(void)
10881 {
10882 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10883 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10884 MS_S32 s32Ret = 0;
10885 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10886
10887 if (pPcmInfo->u8StartFlag != FALSE)
10888 {
10889 /* TODO, there is no such control in DSP */
10890
10891 pPcmInfo->u8StartFlag = FALSE;
10892 }
10893
10894 return s32Ret;
10895 }
10896
HAL_AUDIO_Pcm_Capture1_Set(MS_U32 u32Cmd,const void * pData)10897 MS_S32 HAL_AUDIO_Pcm_Capture1_Set(MS_U32 u32Cmd, const void *pData)
10898 {
10899 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
10900 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
10901 MS_S32 s32Ret = 0;
10902 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10903
10904 if (pData == NULL)
10905 {
10906 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
10907 return -A_EFAULT;
10908 }
10909
10910 if (pPcmInfo->u8ConnectFlag == FALSE)
10911 {
10912 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
10913 return -A_EPERM;
10914 }
10915
10916 if (pPcmInfo->u8StartFlag != FALSE)
10917 {
10918 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
10919 return -A_EBUSY;
10920 }
10921
10922 switch(u32Cmd)
10923 {
10924 case AUDIO_PCM_CMD_NONBLOCKING:
10925 {
10926 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10927
10928 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10929 {
10930 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10931 s32Ret = -A_EINVAL;
10932 break;
10933 }
10934
10935 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10936
10937 break;
10938 }
10939
10940 case AUDIO_PCM_CMD_MULTICH:
10941 {
10942 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10943
10944 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10945 {
10946 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10947 s32Ret = -A_EINVAL;
10948 break;
10949 }
10950
10951 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10952 {
10953 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10954 s32Ret = -A_EINVAL;
10955 break;
10956 }
10957
10958 pPcmInfo->u8MultiChFlag = FALSE;
10959
10960 break;
10961 }
10962
10963 case AUDIO_PCM_CMD_MIXING:
10964 {
10965 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10966
10967 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10968 {
10969 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10970 s32Ret = -A_EINVAL;
10971 break;
10972 }
10973
10974 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10975 {
10976 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
10977 s32Ret = -A_EINVAL;
10978 break;
10979 }
10980
10981 pPcmInfo->u8MixingFlag = FALSE;
10982
10983 break;
10984 }
10985
10986 case AUDIO_PCM_CMD_MIXINGGROUP:
10987 {
10988 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10989
10990 pPcmInfo->u32MixingGroup = u32MixingGroup;
10991
10992 break;
10993 }
10994
10995 case AUDIO_PCM_CMD_BUFFERDURATION:
10996 {
10997 HALAUDIO_ERROR("%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
10998 s32Ret = -A_EPERM;
10999
11000 break;
11001 }
11002
11003 case AUDIO_PCM_CMD_CHANNEL:
11004 {
11005 MS_U32 u32Channel = *((MS_U32 *)pData);
11006
11007 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11008 {
11009 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
11010 return -A_EINVAL;
11011 }
11012
11013 pPcmInfo->u32Channel = u32Channel;
11014
11015 break;
11016 }
11017
11018 case AUDIO_PCM_CMD_SAMPLERATE:
11019 {
11020 HALAUDIO_ERROR("%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
11021 s32Ret = -A_EPERM;
11022
11023 break;
11024 }
11025
11026 case AUDIO_PCM_CMD_BITWIDTH:
11027 {
11028 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11029
11030 pPcmInfo->u32BitWidth = u32BitWidth;
11031
11032 break;
11033 }
11034
11035 case AUDIO_PCM_CMD_BIGENDIEN:
11036 {
11037 MS_U32 u32BigEndien = *((MS_U32 *)pData);
11038
11039 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
11040 {
11041 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
11042 return -A_EINVAL;
11043 }
11044
11045 pPcmInfo->u32BigEndien = u32BigEndien;
11046
11047 break;
11048 }
11049
11050 case AUDIO_PCM_CMD_TIMESTAMP:
11051 {
11052 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11053
11054 pPcmInfo->u32Timestamp = u32Timestamp;
11055
11056 break;
11057 }
11058
11059 case AUDIO_PCM_CMD_WEIGHTING:
11060 {
11061 MS_U32 u32Weighting = *((MS_U32 *)pData);
11062
11063 pPcmInfo->u32Weighting = u32Weighting;
11064
11065 break;
11066 }
11067
11068 case AUDIO_PCM_CMD_VOLUME:
11069 {
11070 MS_U32 u32Volume = *((MS_U32 *)pData);
11071
11072 pPcmInfo->u32Volume = u32Volume;
11073
11074 break;
11075 }
11076
11077 case AUDIO_PCM_CMD_MUTE:
11078 {
11079 MS_U32 u32Mute = *((MS_U32*)pData);
11080
11081 if (u32Mute == TRUE)
11082 {
11083 pPcmInfo->u32Volume |= 0x80000000;
11084 }
11085 else if (u32Mute == FALSE)
11086 {
11087 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11088 }
11089 else
11090 {
11091 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
11092 s32Ret = -A_EINVAL;
11093 }
11094 break;
11095 }
11096
11097 default:
11098 {
11099 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
11100 break;
11101 }
11102 }
11103
11104 return s32Ret;
11105 }
11106
HAL_AUDIO_Pcm_Capture1_Get(MS_U32 u32Cmd,void * pData)11107 MS_S32 HAL_AUDIO_Pcm_Capture1_Get(MS_U32 u32Cmd, void *pData)
11108 {
11109 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
11110 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11111 MS_S32 s32Ret = 0;
11112 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11113
11114 if (pData == NULL)
11115 {
11116 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11117 return -A_EFAULT;
11118 }
11119
11120 if (pPcmInfo->u8ConnectFlag == FALSE)
11121 {
11122 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11123 return -A_EPERM;
11124 }
11125
11126 switch(u32Cmd)
11127 {
11128 case AUDIO_PCM_CMD_ALL:
11129 {
11130 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11131
11132 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
11133 {
11134 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11135 s32Ret = -A_EINVAL;
11136 break;
11137 }
11138
11139 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11140 {
11141 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
11142 s32Ret = -A_EINVAL;
11143 break;
11144 }
11145
11146 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
11147
11148 break;
11149 }
11150
11151 case AUDIO_PCM_CMD_NONBLOCKING:
11152 {
11153 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11154 break;
11155 }
11156
11157 case AUDIO_PCM_CMD_MULTICH:
11158 {
11159 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11160 break;
11161 }
11162
11163 case AUDIO_PCM_CMD_MIXING:
11164 {
11165 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11166 break;
11167 }
11168
11169 case AUDIO_PCM_CMD_MIXINGGROUP:
11170 {
11171 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11172 break;
11173 }
11174
11175 case AUDIO_PCM_CMD_BUFFER:
11176 {
11177 /*
11178 * TODO, need better coding
11179 *
11180 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
11181 */
11182 break;
11183 }
11184
11185 case AUDIO_PCM_CMD_BUFFERDURATION:
11186 {
11187 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11188 break;
11189 }
11190
11191 case AUDIO_PCM_CMD_READPTR:
11192 {
11193 /*
11194 * TODO, need better coding
11195 *
11196 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
11197 */
11198 break;
11199 }
11200
11201 case AUDIO_PCM_CMD_WRITEPTR:
11202 {
11203 /*
11204 * TODO, need better coding
11205 *
11206 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
11207 */
11208 break;
11209 }
11210
11211 case AUDIO_PCM_CMD_CHANNEL:
11212 {
11213 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11214 break;
11215 }
11216
11217 case AUDIO_PCM_CMD_SAMPLERATE:
11218 {
11219 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11220 break;
11221 }
11222
11223 case AUDIO_PCM_CMD_BITWIDTH:
11224 {
11225 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11226 break;
11227 }
11228
11229 case AUDIO_PCM_CMD_BIGENDIEN:
11230 {
11231 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
11232 break;
11233 }
11234
11235 case AUDIO_PCM_CMD_TIMESTAMP:
11236 {
11237 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11238 break;
11239 }
11240
11241 case AUDIO_PCM_CMD_WEIGHTING:
11242 {
11243 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11244 break;
11245 }
11246
11247 case AUDIO_PCM_CMD_VOLUME:
11248 {
11249 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
11250 break;
11251 }
11252
11253 case AUDIO_PCM_CMD_BUFFERLEVEL:
11254 {
11255 MS_U32 u32WritePtrOffset = 0;
11256 MS_U32 u32BufferSize = 0;
11257 MS_S32 s32PcmLevel = 0;
11258
11259 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
11260 pPcmInfo->pWritePtr = pPcmInfo->pBuffer + u32WritePtrOffset;
11261
11262 s32PcmLevel = pPcmInfo->pWritePtr - pPcmInfo->pReadPtr;
11263 if (s32PcmLevel < 0)
11264 {
11265 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
11266 s32PcmLevel += u32BufferSize;
11267 }
11268
11269 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
11270 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11271
11272 break;
11273 }
11274
11275 case AUDIO_PCM_CMD_MUTE:
11276 {
11277 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11278 break;
11279 }
11280
11281 default:
11282 {
11283 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
11284 break;
11285 }
11286 }
11287
11288 return s32Ret;
11289 }
11290
HAL_AUDIO_Pcm_Capture1_Read(void * pBuf,MS_U32 u32Size)11291 MS_U32 HAL_AUDIO_Pcm_Capture1_Read(void *pBuf, MS_U32 u32Size)
11292 {
11293 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
11294 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11295 MS_U8 *pBufTmp = NULL;
11296 MS_U32 u32BufferSize = 0;
11297 MS_U32 u32PcmLevel = 0;
11298 MS_U32 u32RequestSize = 0;
11299 MS_U32 u32RequestSizeTmp = 0;
11300 MS_U32 u32SizeToCopy = 0;
11301 MS_U32 u32RptrOffset = 0;
11302 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11303
11304 if (pBuf == NULL)
11305 {
11306 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11307 return 0;
11308 }
11309
11310 if (u32Size == 0)
11311 {
11312 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
11313 return 0;
11314 }
11315
11316 if (pPcmInfo->u8ConnectFlag == FALSE)
11317 {
11318 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11319 return 0;
11320 }
11321
11322 if (pPcmInfo->u8StartFlag == FALSE)
11323 {
11324 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
11325 return 0;
11326 }
11327
11328 pBufTmp = (MS_U8 *)pBuf;
11329
11330 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
11331 HAL_AUDIO_Pcm_Capture1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
11332 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE1_BUF_UNIT))
11333 {
11334 HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
11335
11336 u32PcmLevel = 0;
11337 HAL_AUDIO_Pcm_Capture1_Stop();
11338 HAL_AUDIO_Pcm_Capture1_Restart();
11339 HAL_AUDIO_Pcm_Capture1_Start();
11340 }
11341
11342 pBufTmp = (MS_U8 *)pBuf;
11343 u32RequestSize = u32Size;
11344 u32RequestSizeTmp = u32RequestSize;
11345
11346 if (u32PcmLevel >= u32RequestSize)
11347 {
11348 do {
11349 u32SizeToCopy = (pPcmInfo->pBuffer + u32BufferSize) - pPcmInfo->pReadPtr;
11350 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11351
11352 memcpy((void *)pBufTmp, (void *)pPcmInfo->pReadPtr, u32SizeToCopy);
11353
11354 pBufTmp += u32SizeToCopy;
11355 pPcmInfo->pReadPtr += u32SizeToCopy;
11356 if (pPcmInfo->pReadPtr >= (pPcmInfo->pBuffer + u32BufferSize))
11357 {
11358 if (pPcmInfo->pReadPtr > (pPcmInfo->pBuffer + u32BufferSize))
11359 {
11360 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11361 }
11362 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
11363 }
11364
11365 u32RequestSizeTmp -= u32SizeToCopy;
11366 } while (u32RequestSizeTmp > 0);
11367
11368 /* flush MIU */
11369 MsOS_FlushMemory();
11370
11371 /* update read pointer to engine */
11372 u32RptrOffset = pPcmInfo->pReadPtr - pPcmInfo->pBuffer;
11373 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
11374
11375 return u32Size;
11376 }
11377
11378 //HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11379
11380 return 0;
11381 }
11382
HAL_AUDIO_Pcm_Capture1_Flush(void)11383 MS_S32 HAL_AUDIO_Pcm_Capture1_Flush(void)
11384 {
11385 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
11386 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11387 MS_S32 s32Ret = 0;
11388 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
11389
11390 if (pPcmInfo->u8StartFlag == FALSE)
11391 {
11392 HAL_AUDIO_Pcm_Capture1_Restart();
11393 HAL_AUDIO_Pcm_Capture1_Stop();
11394 }
11395
11396 return s32Ret;
11397 }
11398
HAL_AUDIO_Pcm_Capture2_Restart(void)11399 MS_S32 HAL_AUDIO_Pcm_Capture2_Restart(void)
11400 {
11401 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11402 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11403 MS_U32 u32WritePtrOffset = 0;
11404 MS_U32 u32TimeoutCounter = 0;
11405 MS_S32 s32Ret = 0;
11406
11407 if (pPcmInfo->u8ConnectFlag == FALSE)
11408 {
11409 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11410 return -A_EPERM;
11411 }
11412
11413 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0x0000);
11414
11415 do {
11416 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
11417
11418 if (u32WritePtrOffset != 0)
11419 {
11420 AUDIO_DELAY1MS(1);
11421 u32TimeoutCounter++;
11422 }
11423 else
11424 {
11425 break;
11426 }
11427 } while (u32TimeoutCounter < 500);
11428
11429 /* clear PCM buffer */
11430 memset((void *)pPcmInfo->pBuffer, 0x00, PCM_CAPTURE2_BUF_SIZE);
11431
11432 /* flush MIU */
11433 MsOS_FlushMemory();
11434
11435 /* reset PCM capture1 read & write pointer */
11436 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
11437 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
11438 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0x0000);
11439
11440 return s32Ret;
11441 }
11442
HAL_AUDIO_Pcm_Capture2_Init(void * pData)11443 MS_S32 HAL_AUDIO_Pcm_Capture2_Init(void *pData)
11444 {
11445 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11446 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11447 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
11448 MS_U32 u32TargetBufferAddrPa = 0;
11449 MS_S32 s32Ret = 0;
11450 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
11451
11452 if (pData == NULL)
11453 {
11454 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11455 return -A_EFAULT;
11456 }
11457
11458 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11459
11460 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
11461 {
11462 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11463 return -A_EINVAL;
11464 }
11465
11466 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11467 {
11468 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
11469 return -A_EINVAL;
11470 }
11471
11472 if (pUserPcmInfo->u8MultiChFlag == TRUE)
11473 {
11474 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11475 return -A_EINVAL;
11476 }
11477
11478 if (pUserPcmInfo->u8MixingFlag == TRUE)
11479 {
11480 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
11481 return -A_EINVAL;
11482 }
11483
11484 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)
11485 {
11486 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
11487 return -A_EINVAL;
11488 }
11489
11490 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)
11491 {
11492 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
11493 return -A_EINVAL;
11494 }
11495
11496 /* fill in settings */
11497 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11498 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
11499 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
11500 pPcmInfo->u8ConnectFlag = TRUE;
11501 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
11502 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
11503 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
11504 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
11505 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
11506 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE2_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
11507 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
11508 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
11509 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
11510 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
11511 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
11512 HAL_AUDIO_Pcm_Capture2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
11513
11514 /* init PCM buffer address */
11515 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
11516 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
11517 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
11518 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
11519
11520 /* restart */
11521 HAL_AUDIO_Pcm_Capture2_Restart();
11522
11523 return s32Ret;
11524 }
11525
HAL_AUDIO_Pcm_Capture2_Exit(void)11526 MS_S32 HAL_AUDIO_Pcm_Capture2_Exit(void)
11527 {
11528 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11529 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11530 MS_S32 s32Ret = 0;
11531 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11532
11533 if (pPcmInfo->u8ConnectFlag != FALSE)
11534 {
11535 HAL_AUDIO_Pcm_Capture2_Flush();
11536 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11537 }
11538
11539 return s32Ret;
11540 }
11541
HAL_AUDIO_Pcm_Capture2_Start(void)11542 MS_S32 HAL_AUDIO_Pcm_Capture2_Start(void)
11543 {
11544 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11545 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11546 MS_U32 u32BufferSize = 0;
11547 MS_S32 s32Ret = 0;
11548 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11549
11550 if (pPcmInfo->u8StartFlag == FALSE)
11551 {
11552 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
11553 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
11554
11555 pPcmInfo->u8StartFlag = TRUE;
11556 }
11557
11558 return s32Ret;
11559 }
11560
HAL_AUDIO_Pcm_Capture2_Stop(void)11561 MS_S32 HAL_AUDIO_Pcm_Capture2_Stop(void)
11562 {
11563 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11564 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11565 MS_S32 s32Ret = 0;
11566 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
11567
11568 if (pPcmInfo->u8StartFlag != FALSE)
11569 {
11570 /* TODO, there is no such control in DSP */
11571
11572 pPcmInfo->u8StartFlag = FALSE;
11573 }
11574
11575 return s32Ret;
11576 }
11577
HAL_AUDIO_Pcm_Capture2_Set(MS_U32 u32Cmd,const void * pData)11578 MS_S32 HAL_AUDIO_Pcm_Capture2_Set(MS_U32 u32Cmd, const void *pData)
11579 {
11580 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11581 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11582 MS_S32 s32Ret = 0;
11583 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11584
11585 if (pData == NULL)
11586 {
11587 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11588 return -A_EFAULT;
11589 }
11590
11591 if (pPcmInfo->u8ConnectFlag == FALSE)
11592 {
11593 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11594 return -A_EPERM;
11595 }
11596
11597 if (pPcmInfo->u8StartFlag != FALSE)
11598 {
11599 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
11600 return -A_EBUSY;
11601 }
11602
11603 switch(u32Cmd)
11604 {
11605 case AUDIO_PCM_CMD_NONBLOCKING:
11606 {
11607 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
11608
11609 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
11610 {
11611 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
11612 s32Ret = -A_EINVAL;
11613 break;
11614 }
11615
11616 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
11617
11618 break;
11619 }
11620
11621 case AUDIO_PCM_CMD_MULTICH:
11622 {
11623 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
11624
11625 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
11626 {
11627 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
11628 s32Ret = -A_EINVAL;
11629 break;
11630 }
11631
11632 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11633 {
11634 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11635 s32Ret = -A_EINVAL;
11636 break;
11637 }
11638
11639 pPcmInfo->u8MultiChFlag = FALSE;
11640
11641 break;
11642 }
11643
11644 case AUDIO_PCM_CMD_MIXING:
11645 {
11646 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
11647
11648 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
11649 {
11650 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
11651 s32Ret = -A_EINVAL;
11652 break;
11653 }
11654
11655 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11656 {
11657 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
11658 s32Ret = -A_EINVAL;
11659 break;
11660 }
11661
11662 pPcmInfo->u8MixingFlag = FALSE;
11663
11664 break;
11665 }
11666
11667 case AUDIO_PCM_CMD_MIXINGGROUP:
11668 {
11669 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
11670
11671 pPcmInfo->u32MixingGroup = u32MixingGroup;
11672
11673 break;
11674 }
11675
11676 case AUDIO_PCM_CMD_BUFFERDURATION:
11677 {
11678 HALAUDIO_ERROR("%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
11679 s32Ret = -A_EPERM;
11680
11681 break;
11682 }
11683
11684 case AUDIO_PCM_CMD_CHANNEL:
11685 {
11686 MS_U32 u32Channel = *((MS_U32 *)pData);
11687
11688 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11689 {
11690 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
11691 return -A_EINVAL;
11692 }
11693
11694 pPcmInfo->u32Channel = u32Channel;
11695
11696 break;
11697 }
11698
11699 case AUDIO_PCM_CMD_SAMPLERATE:
11700 {
11701 HALAUDIO_ERROR("%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
11702 s32Ret = -A_EPERM;
11703
11704 break;
11705 }
11706
11707 case AUDIO_PCM_CMD_BITWIDTH:
11708 {
11709 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11710
11711 pPcmInfo->u32BitWidth = u32BitWidth;
11712
11713 break;
11714 }
11715
11716 case AUDIO_PCM_CMD_BIGENDIEN:
11717 {
11718 MS_U32 u32BigEndien = *((MS_U32 *)pData);
11719
11720 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
11721 {
11722 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
11723 return -A_EINVAL;
11724 }
11725
11726 pPcmInfo->u32BigEndien = u32BigEndien;
11727
11728 break;
11729 }
11730
11731 case AUDIO_PCM_CMD_TIMESTAMP:
11732 {
11733 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11734
11735 pPcmInfo->u32Timestamp = u32Timestamp;
11736
11737 break;
11738 }
11739
11740 case AUDIO_PCM_CMD_WEIGHTING:
11741 {
11742 MS_U32 u32Weighting = *((MS_U32 *)pData);
11743
11744 pPcmInfo->u32Weighting = u32Weighting;
11745
11746 break;
11747 }
11748
11749 case AUDIO_PCM_CMD_VOLUME:
11750 {
11751 MS_U32 u32Volume = *((MS_U32 *)pData);
11752
11753 pPcmInfo->u32Volume = u32Volume;
11754
11755 break;
11756 }
11757
11758 case AUDIO_PCM_CMD_MUTE:
11759 {
11760 MS_U32 u32Mute = *((MS_U32*)pData);
11761
11762 if (u32Mute == TRUE)
11763 {
11764 pPcmInfo->u32Volume |= 0x80000000;
11765 }
11766 else if (u32Mute == FALSE)
11767 {
11768 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11769 }
11770 else
11771 {
11772 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
11773 s32Ret = -A_EINVAL;
11774 }
11775 break;
11776 }
11777
11778 default:
11779 {
11780 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
11781 break;
11782 }
11783 }
11784
11785 return s32Ret;
11786 }
11787
HAL_AUDIO_Pcm_Capture2_Get(MS_U32 u32Cmd,void * pData)11788 MS_S32 HAL_AUDIO_Pcm_Capture2_Get(MS_U32 u32Cmd, void *pData)
11789 {
11790 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11791 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11792 MS_S32 s32Ret = 0;
11793 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11794
11795 if (pData == NULL)
11796 {
11797 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
11798 return -A_EFAULT;
11799 }
11800
11801 if (pPcmInfo->u8ConnectFlag == FALSE)
11802 {
11803 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
11804 return -A_EPERM;
11805 }
11806
11807 switch(u32Cmd)
11808 {
11809 case AUDIO_PCM_CMD_ALL:
11810 {
11811 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11812
11813 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
11814 {
11815 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11816 s32Ret = -A_EINVAL;
11817 break;
11818 }
11819
11820 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11821 {
11822 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
11823 s32Ret = -A_EINVAL;
11824 break;
11825 }
11826
11827 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
11828
11829 break;
11830 }
11831
11832 case AUDIO_PCM_CMD_NONBLOCKING:
11833 {
11834 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11835 break;
11836 }
11837
11838 case AUDIO_PCM_CMD_MULTICH:
11839 {
11840 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11841 break;
11842 }
11843
11844 case AUDIO_PCM_CMD_MIXING:
11845 {
11846 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11847 break;
11848 }
11849
11850 case AUDIO_PCM_CMD_MIXINGGROUP:
11851 {
11852 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11853 break;
11854 }
11855
11856 case AUDIO_PCM_CMD_BUFFER:
11857 {
11858 /*
11859 * TODO, need better coding
11860 *
11861 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
11862 */
11863 break;
11864 }
11865
11866 case AUDIO_PCM_CMD_BUFFERDURATION:
11867 {
11868 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11869 break;
11870 }
11871
11872 case AUDIO_PCM_CMD_READPTR:
11873 {
11874 /*
11875 * TODO, need better coding
11876 *
11877 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
11878 */
11879 break;
11880 }
11881
11882 case AUDIO_PCM_CMD_WRITEPTR:
11883 {
11884 /*
11885 * TODO, need better coding
11886 *
11887 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
11888 */
11889 break;
11890 }
11891
11892 case AUDIO_PCM_CMD_CHANNEL:
11893 {
11894 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11895 break;
11896 }
11897
11898 case AUDIO_PCM_CMD_SAMPLERATE:
11899 {
11900 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11901 break;
11902 }
11903
11904 case AUDIO_PCM_CMD_BITWIDTH:
11905 {
11906 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11907 break;
11908 }
11909
11910 case AUDIO_PCM_CMD_BIGENDIEN:
11911 {
11912 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
11913 break;
11914 }
11915
11916 case AUDIO_PCM_CMD_TIMESTAMP:
11917 {
11918 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11919 break;
11920 }
11921
11922 case AUDIO_PCM_CMD_WEIGHTING:
11923 {
11924 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11925 break;
11926 }
11927
11928 case AUDIO_PCM_CMD_VOLUME:
11929 {
11930 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
11931 break;
11932 }
11933
11934 case AUDIO_PCM_CMD_BUFFERLEVEL:
11935 {
11936 MS_U32 u32WritePtrOffset = 0;
11937 MS_U32 u32BufferSize = 0;
11938 MS_S32 s32PcmLevel = 0;
11939
11940 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
11941 pPcmInfo->pWritePtr = pPcmInfo->pBuffer + u32WritePtrOffset;
11942
11943 s32PcmLevel = pPcmInfo->pWritePtr - pPcmInfo->pReadPtr;
11944 if (s32PcmLevel < 0)
11945 {
11946 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
11947 s32PcmLevel += u32BufferSize;
11948 }
11949
11950 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
11951 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11952
11953 break;
11954 }
11955
11956 case AUDIO_PCM_CMD_MUTE:
11957 {
11958 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11959 break;
11960 }
11961
11962 default:
11963 {
11964 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
11965 break;
11966 }
11967 }
11968
11969 return s32Ret;
11970 }
11971
HAL_AUDIO_Pcm_Capture2_Read(void * pBuf,MS_U32 u32Size)11972 MS_U32 HAL_AUDIO_Pcm_Capture2_Read(void *pBuf, MS_U32 u32Size)
11973 {
11974 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
11975 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
11976 MS_U8 *pBufTmp = NULL;
11977 MS_U32 u32BufferSize = 0;
11978 MS_U32 u32PcmLevel = 0;
11979 MS_U32 u32RequestSize = 0;
11980 MS_U32 u32RequestSizeTmp = 0;
11981 MS_U32 u32SizeToCopy = 0;
11982 MS_U32 u32RptrOffset = 0;
11983 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11984
11985 if (pBuf == NULL)
11986 {
11987 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11988 return 0;
11989 }
11990
11991 if (u32Size == 0)
11992 {
11993 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
11994 return 0;
11995 }
11996
11997 if (pPcmInfo->u8ConnectFlag == FALSE)
11998 {
11999 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12000 return 0;
12001 }
12002
12003 if (pPcmInfo->u8StartFlag == FALSE)
12004 {
12005 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
12006 return 0;
12007 }
12008
12009 pBufTmp = (MS_U8 *)pBuf;
12010
12011 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
12012 HAL_AUDIO_Pcm_Capture2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12013 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE2_BUF_UNIT))
12014 {
12015 HALAUDIO_ERROR("%s: Warning! PCM buffer full!\n", __FUNCTION__);
12016
12017 u32PcmLevel = 0;
12018 HAL_AUDIO_Pcm_Capture2_Stop();
12019 HAL_AUDIO_Pcm_Capture2_Restart();
12020 HAL_AUDIO_Pcm_Capture2_Start();
12021 }
12022
12023 pBufTmp = (MS_U8 *)pBuf;
12024 u32RequestSize = u32Size;
12025 u32RequestSizeTmp = u32RequestSize;
12026
12027 if (u32PcmLevel >= u32RequestSize)
12028 {
12029 do {
12030 u32SizeToCopy = (pPcmInfo->pBuffer + u32BufferSize) - pPcmInfo->pReadPtr;
12031 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12032
12033 memcpy((void *)pBufTmp, (void *)pPcmInfo->pReadPtr, u32SizeToCopy);
12034
12035 pBufTmp += u32SizeToCopy;
12036 pPcmInfo->pReadPtr += u32SizeToCopy;
12037 if (pPcmInfo->pReadPtr >= (pPcmInfo->pBuffer + u32BufferSize))
12038 {
12039 if (pPcmInfo->pReadPtr > (pPcmInfo->pBuffer + u32BufferSize))
12040 {
12041 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12042 }
12043 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
12044 }
12045
12046 u32RequestSizeTmp -= u32SizeToCopy;
12047 } while (u32RequestSizeTmp > 0);
12048
12049 /* flush MIU */
12050 MsOS_FlushMemory();
12051
12052 /* update read pointer to engine */
12053 u32RptrOffset = pPcmInfo->pReadPtr - pPcmInfo->pBuffer;
12054 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
12055
12056 return u32Size;
12057 }
12058
12059 //HALAUDIO_ERROR("%s: Warning! PCM buffer empty!\n", __FUNCTION__);
12060
12061 return 0;
12062 }
12063
HAL_AUDIO_Pcm_Capture2_Flush(void)12064 MS_S32 HAL_AUDIO_Pcm_Capture2_Flush(void)
12065 {
12066 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
12067 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12068 MS_S32 s32Ret = 0;
12069 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12070
12071 if (pPcmInfo->u8StartFlag == FALSE)
12072 {
12073 HAL_AUDIO_Pcm_Capture2_Restart();
12074 HAL_AUDIO_Pcm_Capture2_Stop();
12075 }
12076
12077 return s32Ret;
12078 }
12079
HAL_AUDIO_Pcm_HwDma_Writer1_Restart(void)12080 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Restart(void)
12081 {
12082 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12083 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12084 //MS_U32 u32WritePtrOffset = 0;
12085 //MS_U32 u32TimeoutCounter = 0;
12086 MS_S32 s32Ret = 0;
12087
12088 if (pPcmInfo->u8ConnectFlag == FALSE)
12089 {
12090 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12091 return -A_EPERM;
12092 }
12093
12094 /* clear PCM buffer */
12095 memset((void *)pPcmInfo->pBuffer, 0x00, HW_DMA_WTR1_BUF_SIZE);
12096
12097 /* flush MIU */
12098 MsOS_FlushMemory();
12099 return s32Ret;
12100 }
12101
HAL_AUDIO_Pcm_HwDma_Writer1_Init(void * pData)12102 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Init(void *pData)
12103 {
12104 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12105 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12106 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
12107 MS_U32 u32TargetBufferAddrPa = 0;
12108 MS_U32 u32TargetBufferSize = 0;
12109 MS_U32 u32TargetChannel = 0;
12110 MS_S32 s32Ret = 0;
12111 HALAUDIO_ERROR("%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
12112
12113 if (pData == NULL)
12114 {
12115 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12116 return -A_EFAULT;
12117 }
12118
12119 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12120
12121 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
12122 {
12123 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12124 return -A_EINVAL;
12125 }
12126
12127 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12128 {
12129 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
12130 return -A_EINVAL;
12131 }
12132
12133 if (pUserPcmInfo->u8MultiChFlag == TRUE)
12134 {
12135 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12136 return -A_EINVAL;
12137 }
12138
12139 if (pUserPcmInfo->u8MixingFlag == TRUE)
12140 {
12141 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
12142 return -A_EINVAL;
12143 }
12144
12145 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)
12146 {
12147 HALAUDIO_ERROR("%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
12148 return -A_EINVAL;
12149 }
12150
12151 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)
12152 {
12153 HALAUDIO_ERROR("%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
12154 return -A_EINVAL;
12155 }
12156
12157 /* fill in settings */
12158 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12159 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
12160 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
12161 pPcmInfo->u8ConnectFlag = TRUE;
12162 strcpy((char *)pPcmInfo->u8Name, (char *)pPCM->u8Name);
12163 strcpy((char *)pUserPcmInfo->u8Name, (char *)pPCM->u8Name);
12164
12165 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
12166 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
12167 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
12168 pPcmInfo->u32BufferDuration = ((HW_DMA_WTR1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
12169 // HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
12170 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
12171 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
12172 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
12173 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_BIGENDIEN, &pUserPcmInfo->u32BigEndien);
12174 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
12175 HAL_AUDIO_Pcm_HwDma_Writer1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
12176
12177 /* init PCM buffer address */
12178 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR;
12179 pPcmInfo->pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
12180 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
12181 pPcmInfo->pWritePtr = pPcmInfo->pBuffer;
12182
12183 /* set PCM buffer address */
12184 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
12185 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE) & 0xFFFF);
12186 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
12187
12188
12189 /* calculate buffer size */
12190 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x80, 0x80); //start
12191 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x0F, M2S_MBOX_GET_Raw);
12192
12193 u32TargetChannel = 2;
12194 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * 2) / 1000;
12195 if (u32TargetBufferSize > HW_DMA_WTR1_BUF_SIZE)
12196 {
12197 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);
12198 u32TargetBufferSize = HW_DMA_WTR1_BUF_SIZE;
12199 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * 2));
12200 HALAUDIO_ERROR("%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
12201 }
12202
12203 /* set buffer size */
12204 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
12205 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
12206
12207 /* Reset and Start DMA Writer */
12208 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
12209 AUDIO_DELAY1US(1);
12210 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
12211
12212 /* restart */
12213 HAL_AUDIO_Pcm_HwDma_Writer1_Restart();
12214
12215 return s32Ret;
12216 }
12217
HAL_AUDIO_Pcm_HwDma_Writer1_Exit(void)12218 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Exit(void)
12219 {
12220 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12221 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12222 MS_S32 s32Ret = 0;
12223 HALAUDIO_ERROR("%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
12224
12225 if (pPcmInfo->u8ConnectFlag != FALSE)
12226 {
12227 HAL_AUDIO_Pcm_HwDma_Writer1_Flush();
12228 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12229 }
12230
12231 return s32Ret;
12232 }
12233
HAL_AUDIO_Pcm_HwDma_Writer1_Start(void)12234 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Start(void)
12235 {
12236 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12237 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12238 //MS_U32 u32BufferSize = 0;
12239 MS_S32 s32Ret = 0;
12240 HALAUDIO_ERROR("%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
12241
12242 if (pPcmInfo->u8StartFlag == FALSE)
12243 {
12244 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0001);
12245 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0002);
12246
12247 pPcmInfo->u8StartFlag = TRUE;
12248 }
12249
12250 return s32Ret;
12251 }
12252
HAL_AUDIO_Pcm_HwDma_Writer1_Stop(void)12253 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Stop(void)
12254 {
12255 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12256 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12257 MS_S32 s32Ret = 0;
12258 HALAUDIO_ERROR("%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
12259
12260 if (pPcmInfo->u8StartFlag != FALSE)
12261 {
12262 /* TODO, there is no such control in DSP */
12263
12264 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0000);
12265 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0000);
12266
12267 pPcmInfo->u8StartFlag = FALSE;
12268 }
12269
12270 return s32Ret;
12271 }
12272
HAL_AUDIO_Pcm_HwDma_Writer1_Set(MS_U32 u32Cmd,const void * pData)12273 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Set(MS_U32 u32Cmd, const void *pData)
12274 {
12275 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12276 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12277 MS_S32 s32Ret = 0;
12278 //HALAUDIO_ERROR("%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12279
12280 if (pData == NULL)
12281 {
12282 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12283 return -A_EFAULT;
12284 }
12285
12286 if (pPcmInfo->u8ConnectFlag == FALSE)
12287 {
12288 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12289 return -A_EPERM;
12290 }
12291
12292 if (pPcmInfo->u8StartFlag != FALSE)
12293 {
12294 HALAUDIO_ERROR("%s: Error! Running now, not allow to be configured!\n", __FUNCTION__);
12295 return -A_EBUSY;
12296 }
12297
12298 switch(u32Cmd)
12299 {
12300 case AUDIO_PCM_CMD_NONBLOCKING:
12301 {
12302 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
12303
12304 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
12305 {
12306 HALAUDIO_ERROR("%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
12307 s32Ret = -A_EINVAL;
12308 break;
12309 }
12310
12311 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
12312
12313 break;
12314 }
12315
12316 case AUDIO_PCM_CMD_MULTICH:
12317 {
12318 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
12319
12320 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
12321 {
12322 HALAUDIO_ERROR("%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
12323 s32Ret = -A_EINVAL;
12324 break;
12325 }
12326
12327 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12328 {
12329 HALAUDIO_ERROR("%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12330 s32Ret = -A_EINVAL;
12331 break;
12332 }
12333
12334 pPcmInfo->u8MultiChFlag = FALSE;
12335
12336 break;
12337 }
12338
12339 case AUDIO_PCM_CMD_MIXING:
12340 {
12341 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
12342
12343 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
12344 {
12345 HALAUDIO_ERROR("%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
12346 s32Ret = -A_EINVAL;
12347 break;
12348 }
12349
12350 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12351 {
12352 HALAUDIO_ERROR("%s: Error! Not support mixing mode!\n", __FUNCTION__);
12353 s32Ret = -A_EINVAL;
12354 break;
12355 }
12356
12357 pPcmInfo->u8MixingFlag = FALSE;
12358
12359 break;
12360 }
12361
12362 case AUDIO_PCM_CMD_MIXINGGROUP:
12363 {
12364 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
12365
12366 pPcmInfo->u32MixingGroup = u32MixingGroup;
12367
12368 break;
12369 }
12370
12371 case AUDIO_PCM_CMD_BUFFERDURATION:
12372 {
12373 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
12374
12375 if (u32BufferDuration == 0)
12376 {
12377 HALAUDIO_ERROR("%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
12378 s32Ret = -A_EINVAL;
12379 break;
12380 }
12381
12382 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
12383 {
12384 pPcmInfo->u32BufferDuration = u32BufferDuration;
12385 pPCM->u8SettingChangeFlag = TRUE;
12386 }
12387
12388 break;
12389 }
12390
12391 case AUDIO_PCM_CMD_CHANNEL:
12392 {
12393 MS_U32 u32Channel = *((MS_U32 *)pData);
12394
12395 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12396 {
12397 HALAUDIO_ERROR("%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
12398 return -A_EINVAL;
12399 }
12400
12401 pPcmInfo->u32Channel = u32Channel;
12402
12403 break;
12404 }
12405
12406 case AUDIO_PCM_CMD_SAMPLERATE:
12407 {
12408 MS_U32 u32SampleRate = *((MS_U32 *)pData);
12409
12410 if (HAL_AUDIO_Pcm_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12411 {
12412 HALAUDIO_ERROR("%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
12413 return -A_EINVAL;
12414 }
12415
12416 if (pPcmInfo->u32SampleRate != u32SampleRate)
12417 {
12418 pPcmInfo->u32SampleRate = u32SampleRate;
12419 pPCM->u8SettingChangeFlag = TRUE;
12420 }
12421
12422 break;
12423 }
12424
12425 case AUDIO_PCM_CMD_BITWIDTH:
12426 {
12427 MS_U32 u32BitWidth = *((MS_U32 *)pData);
12428
12429 pPcmInfo->u32BitWidth = u32BitWidth;
12430
12431 break;
12432 }
12433
12434 case AUDIO_PCM_CMD_BIGENDIEN:
12435 {
12436 MS_U32 u32BigEndien = *((MS_U32 *)pData);
12437
12438 if ((u32BigEndien != TRUE) && (u32BigEndien != FALSE))
12439 {
12440 HALAUDIO_ERROR("%s: Error! invalid u32BigEndien(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndien);
12441 return -A_EINVAL;
12442 }
12443
12444 pPcmInfo->u32BigEndien = u32BigEndien;
12445
12446 break;
12447 }
12448
12449 case AUDIO_PCM_CMD_TIMESTAMP:
12450 {
12451 MS_U32 u32Timestamp = *((MS_U32 *)pData);
12452
12453 pPcmInfo->u32Timestamp = u32Timestamp;
12454
12455 break;
12456 }
12457
12458 case AUDIO_PCM_CMD_WEIGHTING:
12459 {
12460 MS_U32 u32Weighting = *((MS_U32 *)pData);
12461
12462 pPcmInfo->u32Weighting = u32Weighting;
12463
12464 break;
12465 }
12466
12467 case AUDIO_PCM_CMD_VOLUME:
12468 {
12469 MS_U32 u32Volume = *((MS_U32 *)pData);
12470
12471 pPcmInfo->u32Volume = u32Volume;
12472
12473 break;
12474 }
12475
12476 case AUDIO_PCM_CMD_MUTE:
12477 {
12478 MS_U32 u32Mute = *((MS_U32*)pData);
12479
12480 if (u32Mute == TRUE)
12481 {
12482 pPcmInfo->u32Volume |= 0x80000000;
12483 }
12484 else if (u32Mute == FALSE)
12485 {
12486 pPcmInfo->u32Volume &= 0x7FFFFFFF;
12487 }
12488 else
12489 {
12490 HALAUDIO_ERROR("%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
12491 s32Ret = -A_EINVAL;
12492 }
12493 break;
12494 }
12495
12496 default:
12497 {
12498 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
12499 break;
12500 }
12501 }
12502
12503 return s32Ret;
12504 }
12505
HAL_AUDIO_Pcm_HwDma_Writer1_Get(MS_U32 u32Cmd,void * pData)12506 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Get(MS_U32 u32Cmd, void *pData)
12507 {
12508 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12509 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12510 MS_S32 s32Ret = 0;
12511 //HALAUDIO_ERROR("%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12512
12513 if (pData == NULL)
12514 {
12515 HALAUDIO_ERROR("%s: Error! pData should not be NULL!\n", __FUNCTION__);
12516 return -A_EFAULT;
12517 }
12518
12519 if (pPcmInfo->u8ConnectFlag == FALSE)
12520 {
12521 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12522 return -A_EPERM;
12523 }
12524
12525 switch(u32Cmd)
12526 {
12527 case AUDIO_PCM_CMD_ALL:
12528 {
12529 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12530
12531 if (pUserPcmInfo->u32StructVersion != AUDIO_PCM_INFO_VERSION)
12532 {
12533 HALAUDIO_ERROR("%s: Error! The version of PCM Info mismatch(%u, %d)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12534 s32Ret = -A_EINVAL;
12535 break;
12536 }
12537
12538 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12539 {
12540 HALAUDIO_ERROR("%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
12541 s32Ret = -A_EINVAL;
12542 break;
12543 }
12544
12545 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, sizeof(AUDIO_PCM_INFO_t));
12546
12547 break;
12548 }
12549
12550 case AUDIO_PCM_CMD_NONBLOCKING:
12551 {
12552 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
12553 break;
12554 }
12555
12556 case AUDIO_PCM_CMD_MULTICH:
12557 {
12558 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
12559 break;
12560 }
12561
12562 case AUDIO_PCM_CMD_MIXING:
12563 {
12564 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
12565 break;
12566 }
12567
12568 case AUDIO_PCM_CMD_MIXINGGROUP:
12569 {
12570 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
12571 break;
12572 }
12573
12574 case AUDIO_PCM_CMD_BUFFER:
12575 {
12576 /*
12577 * TODO, need better coding
12578 *
12579 * *((MS_S8 *)pData) = pPcmInfo->pBuffer;
12580 */
12581 break;
12582 }
12583
12584 case AUDIO_PCM_CMD_BUFFERDURATION:
12585 {
12586 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
12587 break;
12588 }
12589
12590 case AUDIO_PCM_CMD_READPTR:
12591 {
12592 /*
12593 * TODO, need better coding
12594 *
12595 * *((MS_S8 *)pData) = pPcmInfo->pReadPtr;
12596 */
12597 break;
12598 }
12599
12600 case AUDIO_PCM_CMD_WRITEPTR:
12601 {
12602 /*
12603 * TODO, need better coding
12604 *
12605 * *((MS_S8 *)pData) = pPcmInfo->pWritePtr;
12606 */
12607 break;
12608 }
12609
12610 case AUDIO_PCM_CMD_CHANNEL:
12611 {
12612 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
12613 break;
12614 }
12615
12616 case AUDIO_PCM_CMD_SAMPLERATE:
12617 {
12618 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
12619 break;
12620 }
12621
12622 case AUDIO_PCM_CMD_BITWIDTH:
12623 {
12624 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
12625 break;
12626 }
12627
12628 case AUDIO_PCM_CMD_BIGENDIEN:
12629 {
12630 *((MS_U32 *)pData) = pPcmInfo->u32BigEndien;
12631 break;
12632 }
12633
12634 case AUDIO_PCM_CMD_TIMESTAMP:
12635 {
12636 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
12637 break;
12638 }
12639
12640 case AUDIO_PCM_CMD_WEIGHTING:
12641 {
12642 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
12643 break;
12644 }
12645
12646 case AUDIO_PCM_CMD_VOLUME:
12647 {
12648 *((MS_U32 *)pData) = pPcmInfo->u32Volume;
12649 break;
12650 }
12651
12652 case AUDIO_PCM_CMD_BUFFERLEVEL:
12653 {
12654 //MS_U32 u32WritePtrOffset = 0;
12655 //MS_U32 u32BufferSize = 0;
12656 MS_S32 s32PcmLevel1 = 0, s32PcmLevel2;
12657 MS_U16 time_out = 0;
12658
12659 s32PcmLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
12660 s32PcmLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
12661 while ((s32PcmLevel1 != s32PcmLevel2) && (time_out++<2000))
12662 {
12663 s32PcmLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
12664 s32PcmLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
12665 }
12666 pPcmInfo->u32BufferLevel = s32PcmLevel1 * BYTES_IN_MIU_LINE;
12667 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12668 break;
12669 }
12670
12671 case AUDIO_PCM_CMD_MUTE:
12672 {
12673 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12674 break;
12675 }
12676
12677 default:
12678 {
12679 HALAUDIO_ERROR("%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
12680 break;
12681 }
12682 }
12683
12684 return s32Ret;
12685 }
12686
HAL_AUDIO_Pcm_HwDma_Writer1_Read(void * pBuf,MS_U32 u32Size)12687 MS_U32 HAL_AUDIO_Pcm_HwDma_Writer1_Read(void *pBuf, MS_U32 u32Size)
12688 {
12689 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12690 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12691 MS_U8 *pBufTmp = NULL;
12692 MS_U32 u32BufferSize = 0;
12693 MS_U32 u32PcmLevel = 0;
12694 MS_U32 u32RequestSize = 0;
12695 MS_U32 u32RequestSizeTmp = 0;
12696 MS_U32 u32SizeToCopy = 0;
12697 //MS_U32 u32RptrOffset = 0;
12698 //HALAUDIO_ERROR("%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
12699
12700 if (pBuf == NULL)
12701 {
12702 HALAUDIO_ERROR("%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
12703 return 0;
12704 }
12705
12706 if (u32Size == 0)
12707 {
12708 HALAUDIO_ERROR("%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
12709 return 0;
12710 }
12711
12712 if (pPcmInfo->u8ConnectFlag == FALSE)
12713 {
12714 HALAUDIO_ERROR("%s: Error! Not opened yet!\n", __FUNCTION__);
12715 return 0;
12716 }
12717
12718 if (pPcmInfo->u8StartFlag == FALSE)
12719 {
12720 HALAUDIO_ERROR("%s: Error! Not started yet!\n", __FUNCTION__);
12721 return 0;
12722 }
12723
12724 pBufTmp = (MS_U8 *)pBuf;
12725
12726 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
12727 HAL_AUDIO_Pcm_HwDma_Writer1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12728 pBufTmp = (MS_U8 *)pBuf;
12729 u32RequestSize = u32Size;
12730 u32RequestSizeTmp = u32RequestSize;
12731
12732 if (u32PcmLevel >= u32RequestSize)
12733 {
12734 do {
12735 u32SizeToCopy = (pPcmInfo->pBuffer + u32BufferSize) - pPcmInfo->pReadPtr;
12736 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12737
12738 memcpy((void *)pBufTmp, (void *)pPcmInfo->pReadPtr, u32SizeToCopy);
12739
12740 pBufTmp += u32SizeToCopy;
12741 pPcmInfo->pReadPtr += u32SizeToCopy;
12742 if (pPcmInfo->pReadPtr >= (pPcmInfo->pBuffer + u32BufferSize))
12743 {
12744 if (pPcmInfo->pReadPtr > (pPcmInfo->pBuffer + u32BufferSize))
12745 {
12746 HALAUDIO_ERROR("%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12747 }
12748 pPcmInfo->pReadPtr = pPcmInfo->pBuffer;
12749 }
12750
12751 u32RequestSizeTmp -= u32SizeToCopy;
12752 } while (u32RequestSizeTmp > 0);
12753
12754 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
12755 HAL_AUR2_WriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
12756 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
12757 return u32Size;
12758 }
12759 return 0;
12760 }
12761
HAL_AUDIO_Pcm_HwDma_Writer1_Flush(void)12762 MS_S32 HAL_AUDIO_Pcm_HwDma_Writer1_Flush(void)
12763 {
12764 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
12765 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->tPcmInfo;
12766 MS_S32 s32Ret = 0;
12767 HALAUDIO_ERROR("%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12768
12769 if (pPcmInfo->u8StartFlag == FALSE)
12770 {
12771 HAL_AUDIO_Pcm_HwDma_Writer1_Restart();
12772 HAL_AUDIO_Pcm_HwDma_Writer1_Stop();
12773 }
12774
12775 return s32Ret;
12776 }
12777
HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)12778 AUDIO_DSP_CODE_TYPE HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)
12779 {
12780 AUDIO_DSP_CODE_TYPE dspCodeType = AU_DVB_STANDARD_INVALID;
12781
12782 switch (enDecSystem)
12783 {
12784 case MSAPI_AUD_ATV_BTSC:
12785 dspCodeType = AU_SIF_BTSC;
12786 break;
12787 case MSAPI_AUD_ATV_PAL:
12788 dspCodeType = AU_SIF_PALSUM;
12789 break;
12790 case MSAPI_AUD_DVB_MPEG:
12791 dspCodeType = AU_DVB_STANDARD_MPEG;
12792 break;
12793 case MSAPI_AUD_DVB_AC3:
12794 dspCodeType = AU_DVB_STANDARD_AC3;
12795 break;
12796 case MSAPI_AUD_DVB_AC3P:
12797 dspCodeType = AU_DVB_STANDARD_AC3P;
12798 break;
12799 case MSAPI_AUD_DVB_AAC:
12800 dspCodeType = AU_DVB_STANDARD_AAC;
12801 break;
12802 case MSAPI_AUD_DVB_MP3:
12803 dspCodeType = AU_DVB_STANDARD_MP3;
12804 break;
12805 case MSAPI_AUD_DVB_WMA:
12806 dspCodeType = AU_DVB_STANDARD_WMA;
12807 break;
12808 case MSAPI_AUD_DVB_RA8LBR:
12809 dspCodeType = AU_DVB_STANDARD_RA8LBR;
12810 break;
12811 case MSAPI_AUD_DVB_XPCM:
12812 dspCodeType = AU_DVB_STANDARD_XPCM;
12813 break;
12814 case MSAPI_AUD_DVB_DTS:
12815 dspCodeType = AU_DVB_STANDARD_DTS;
12816 break;
12817 case MSAPI_AUD_DVB_MS10_DDT:
12818 dspCodeType = AU_DVB_STANDARD_MS10_DDT;
12819 break;
12820 case MSAPI_AUD_DVB_MS10_DDC:
12821 dspCodeType = AU_DVB_STANDARD_MS10_DDC;
12822 break;
12823 case MSAPI_AUD_DVB_WMA_PRO:
12824 dspCodeType = AU_DVB_STANDARD_WMA_PRO;
12825 break;
12826 case MSAPI_AUD_DVB_FLAC:
12827 dspCodeType = AU_DVB_STANDARD_FLAC;
12828 break;
12829 case MSAPI_AUD_DVB_VORBIS:
12830 dspCodeType = AU_DVB_STANDARD_VORBIS;
12831 break;
12832 case MSAPI_AUD_DVB_DTSLBR:
12833 dspCodeType = AU_DVB_STANDARD_DTSLBR;
12834 break;
12835 case MSAPI_AUD_DVB_DRA:
12836 dspCodeType = AU_DVB_STANDARD_DRA;
12837 break;
12838 default:
12839 break;
12840 }
12841
12842 return dspCodeType;
12843 }
12844
HAL_AUDIO_ResetDspCodeType(void)12845 void HAL_AUDIO_ResetDspCodeType(void)
12846 {
12847 g_AudioVars2->g_DspCodeType = AU_DVB_STANDARD_INVALID;
12848 g_AudioVars2->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
12849 g_AudioVars2->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
12850 }
12851
HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)12852 MS_S32 HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)
12853 {
12854 return 0;
12855 }