1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 //-------------------------------------------------------------------------------------------------
96 // Include Files
97 //-------------------------------------------------------------------------------------------------
98 // Common Definition
99 #ifdef MSOS_TYPE_LINUX_KERNEL
100 #include <linux/string.h>
101 #include <linux/slab.h>
102 #include <linux/delay.h>
103 #include <linux/sched.h>
104 #include <linux/kthread.h>
105 #include <linux/jiffies.h>
106 #include <asm/io.h>
107 #else
108 #include <stdio.h>
109 #include <string.h>
110 #include <pthread.h>
111 #endif
112
113 #include "MsCommon.h"
114 #include "MsIRQ.h"
115 #include "MsOS.h"
116 #include "MsTypes.h"
117 #include "drvSYS.h"
118 #include "../sys/halSYS.h"
119
120 // Internal Definition
121 #include "drvAUDIO.h"
122 #include "regCHIP.h"
123 #include "regAUDIO.h"
124 #include "halAUDIO.h"
125 #include "halMAD.h"
126 #include "halMAD2.h"
127 #include "halSIF.h"
128 #include "halSOUND.h"
129 #include "halAUR2.h"
130 #include "decR2_version.h"
131 #if ASND_R2_SUPPORT
132 #include "sndR2_version.h"
133 #endif
134 #include "../audsp/halAUDSP.h"
135 #include "../../../drv/audio/internal/drvAUDIO_internal.h"
136
137
138
139 //-------------------------------------------------------------------------------------------------
140 // Driver Compiler Options
141 //-------------------------------------------------------------------------------------------------
142 #define HALAUDIO_CHECK_SHM_INIT \
143 do { \
144 if (g_AudioVars2 == NULL) \
145 { \
146 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Warning! g_AudioVars2 should not be NULL !!!\n", __FUNCTION__); \
147 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Perform SHM Init here !!!\n", __FUNCTION__); \
148 if (HAL_AUDIO_InitialVars() == FALSE) \
149 { \
150 MS_ASSERT(0); \
151 } \
152 } \
153 } while(0)
154
155 #ifndef MSOS_TYPE_NOS
156 void* MDrv_MPool_PA2KSEG1(void* pAddrPhys);
157 #endif
158
159 //-------------------------------------------------------------------------------------------------
160 // Local Defines
161 //-------------------------------------------------------------------------------------------------
162 #define HINIBBLE(u8Data) ((u8Data) >> 4)
163 #define LONIBBLE(u8Data) ((u8Data) << 4)
164 #if (AUDIO_R2_DMA_READER1_SUPPORT || AUDIO_R2_DMA_READER2_SUPPORT)
165 #define AUDIO_R2_DMA_RDER_CFG_REG(base, offset) ((MS_U32)(base + (offset * 2)))
166 #endif
167
168 #define HW_DMA_RDR1_BUF_UNIT 4096
169
170 #if AUDIO_HW_DMA_READER1_SUPPORT
171 #define HW_DMA_RDR1_BUF_ADDR (DSP2_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
172 #define HW_DMA_RDR1_BUF_SIZE ((DSP2_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
173 #endif
174
175 #if AUDIO_HW_DMA_READER2_SUPPORT
176 #define HW_DMA_RDR2_BUF_ADDR (DSP2_HW_DMA_READER2_DRAM_BASE * BYTES_IN_MIU_LINE)
177 #define HW_DMA_RDR2_BUF_SIZE ((DSP2_HW_DMA_READER2_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
178 #endif
179
180 #if AUDIO_SW_DMA_READER1_SUPPORT
181 #define SW_DMA_RDR1_BUF_ADDR (DSP2_SW_DMA_READER_DRAM_BASE * BYTES_IN_MIU_LINE)
182 #define SW_DMA_RDR1_BUF_SIZE ((DSP2_SW_DMA_READER_DRAM_SIZE + 1) * BYTES_IN_MIU_LINE)
183 #endif
184
185 #if AUDIO_R2_DMA_READER1_SUPPORT
186 #define R2_DMA_RDR1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA1_READER_DRAM_BASE)
187 #define R2_DMA_RDR1_BUF_SIZE MCU_R2_DMA1_READER_DRAM_SIZE
188 #endif
189
190 #if AUDIO_R2_DMA_READER2_SUPPORT
191 #define R2_DMA_RDR2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MCU_R2_DMA2_READER_DRAM_BASE)
192 #define R2_DMA_RDR2_BUF_SIZE MCU_R2_DMA2_READER_DRAM_SIZE
193 #endif
194
195 #if AUDIO_PCM_CAPTURE1_SUPPORT
196 #define PCM_CAPTURE1_BUF_UNIT 128
197 #define PCM_CAPTURE1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
198 #define PCM_CAPTURE1_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
199 #endif
200
201 #if AUDIO_PCM_CAPTURE2_SUPPORT
202 #define PCM_CAPTURE2_BUF_UNIT 128
203 #define PCM_CAPTURE2_BUF_ADDR (DSP2_PCM_CAPTURE2_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
204 #define PCM_CAPTURE2_BUF_SIZE (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)
205 #endif
206
207 #if AUDIO_HW_DMA_WRITER1_SUPPORT
208 #define HW_DMA_WTR1_BUF_ADDR (DSP2_PCM_CAPTURE_BUFFER_DRAM_BASE * BYTES_IN_MIU_LINE)
209 #define HW_DMA_WTR1_BUF_SIZE ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE) * BYTES_IN_MIU_LINE)
210 #endif
211
212 #if AUDIO_MP3_ENCODER1_SUPPORT
213 #define MP3_ENCODER1_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MP3_ENC_DRAM_BASE)
214 #define MP3_ENCODER1_BUF_SIZE (MP3_ENC_DRAM_SIZE)
215 #endif
216
217 #if AUDIO_MP3_ENCODER2_SUPPORT
218 #define MP3_ENCODER2_BUF_ADDR (ASND_DSP_DDR_SIZE + OFFSET_MP3_ENC2_DRAM_BASE)
219 #define MP3_ENCODER2_BUF_SIZE (MP3_ENC2_DRAM_SIZE)
220 #endif
221
222 #ifndef UNUSED
223 #define UNUSED(x) ((x)=(x))
224 #endif
225
226 #define StereoAACOutputPCM 0
227
228 //-------------------------------------------------------------------------------------------------
229 // Local Structures
230 //-------------------------------------------------------------------------------------------------
231
232 //-------------------------------------------------------------------------------------------------
233 // Global Variables
234 //-------------------------------------------------------------------------------------------------
235 AUDIO_SOURCE_INFO_TYPE AudioInputSrcInfo;
236 MS_U16 g_BalanceMask = 0x0000;
237 MS_BOOL g_bAudio_loadcode_from_dram = 0, g_bIsDTV;
238 MS_VIRT _gMIO_MapBase;
239 MS_U32 g_u32bDTSCD = 0x00;
240 MS_S32 _s32AUDIOMutex = -1;
241 MS_S32 _s32AUDIOMutexReboot = -1;
242 MS_S32 _s32MutexLoadCode = -1;
243 MS_S32 _s32AUDIOMutexIDMA = -1;
244 MS_U8 CheckPlayDoneCnt = 0;
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_ID3 , 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 static AU_DVB_DECCMD MAD2DecCMD = AU_DVB_DECCMD_STOP;
297 static AU_DVB_DECCMD MADDec1CMD = AU_DVB_DECCMD_STOP;
298 static AU_DVB_DECCMD MADDec2CMD = AU_DVB_DECCMD_STOP;
299 static adec_type MADDec1Type = adec_type_dummy;
300 static adec_type MADDec2Type = adec_type_dummy;
301
302 MS_PHY g_pcm_capture_base_addr = 0;
303 MS_PHY g_pcm_capture2_base_addr = 0;
304
305 MS_U8 g_DSPMadMIUBank[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
306 MS_PHY g_DSPBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
307 MS_PHY g_DSPMadBaseBufferAdr[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
308 MS_PHY g_DSPDDRBinBaseAddress[MAX_AUDIO_BASE_ADDRESS_NUM2] = {0};
309 extern MS_PHY (* gGetDDRInfoFuncPtr)(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo);
310
311 extern MS_U32 g_AudioDumpInfoCtrl;
312 extern MS_BOOL bIsNonPCMInDec2;
313 extern MS_U32 EncFrameIdx;
314 extern MS_U32 EncBuf_W_idx;
315 extern MS_U8 EncBuf_Count;
316 extern AU_DVB_ENC_FRAME_INFO MPEG_EN_BUF[6];
317
318 extern AUDIO_DEC_ID (* gOpenDecodeSystemFuncPtr)(AudioDecStatus_t * p_AudioDecStatus);
319 extern MS_BOOL (*pFuncPtr_Setsystem)(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus);
320 extern MS_BOOL (* gDigitalOutChannelStatusFuncPtr)(DIGITAL_OUTPUT_TYPE , Digital_Out_Channel_Status_t *);
321
322 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit);
323
324
325 const MS_U32 u32PathArray[8]={0x2C64, 0x2C66, 0x2C68, 0x2C6A, 0x2C65, 0x2C67, 0x2C69, 0x2C6B};
326
327 //Refine power on sequence for earphone & DAC pop noise issue
328 const AUDIO_REG_TYPE AudioPreInitTbl_Clock[] =
329 {
330
331 //-----------------Unsorted-----------------------------//Item TMP Add: setting for MPLL
332
333 //----------------AUPLL control-------------------------//Item 23
334 {0x112C9E, 0xFF, 0x20},
335 {0x112C9F, 0xFF, 0x1C},
336 {0x112C9C, 0xFF, 0x00},
337 {0x112C9D, 0xFF, 0xC0},
338 {0x112CA0, 0xFF, 0x20},
339 {0x112CA1, 0xFF, 0x1C},
340 {0x112C9C, 0xFF, 0x00},
341 {0x112C9D, 0xFF, 0x80},
342 {0x112CA2, 0x08, 0x08},// Enable reference clock
343 {0x112CA2, 0x10, 0x10},// Select 1st-order or 2nd-order synthesizer
344 {0x112C70, 0xFF, 0xD0},
345 {0x112C71, 0xFF, 0x12},
346 {0x112C76, 0xFF, 0x00},
347 {0x112C77, 0xFF, 0x03},
348
349 //----------------AUR2 PLL (MPLL)------------------------//Item 22
350 {0x160342, 0xFF, 0x01},
351 {0x160343, 0xFF, 0x00},
352
353 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
354
355 //---------------- Enable CLK----------------------------//Item 32
356 // DFS for DSP.
357 {0x163C61, 0x10, 0x00},
358 {0x163C61, 0x03, 0x02},
359 {0x163C60, 0x40, 0x40},
360 {0x163C60, 0x1F, 0x1F},
361 {0x163C61, 0x08, 0x08},
362 {0x163C60, 0x80, 0x00},
363 {0x163C60, 0x80, 0x80},
364 {0x163C60, 0x80, 0x00},
365
366 // DFS for R2.
367 {0x163C63, 0x03, 0x00},
368 {0x163C63, 0x10, 0x00},
369 {0x163C62, 0x40, 0x40},
370 {0x163C62, 0x1F, 0x1F},
371 {0x163C63, 0x08, 0x08},
372 {0x163C62, 0x80, 0x00},
373 {0x163C62, 0x80, 0x80},
374 {0x163C62, 0x80, 0x00},
375
376 {0x112CA4, 0xFF, 0xFF},
377 {0x112CA5, 0xFF, 0x1F},
378 {0x112CB3, 0x60, 0x60}, // Enable DEC_R2 Clock
379 {0x112CB2, 0x80, 0x80}, // Enable SND_R2 Clock
380 {0x112CB2, 0x10, 0x10}, // Enable Parser clock
381 {0x112CCB, 0x3C, 0x3C}, // Enable DSP clock
382
383 //------------------------------------------------------//Item 35
384 {0x112B70, 0xFF, 0x00},
385 {0x112B71, 0xFF, 0xC0},
386
387 {0x112B72, 0xFF, 0x00},
388 {0x112B73, 0xFF, 0x00},
389 {0x112B70, 0xFF, 0x00},
390 {0x112B71, 0xFF, 0xE0},
391 {0x112B70, 0xFF, 0x00},
392 {0x112B71, 0xFF, 0xC0},
393
394 {0x112B72, 0xFF, 0x00},
395 {0x112B73, 0xFF, 0x00},
396 {0x112B70, 0xFF, 0x00},
397 {0x112B71, 0xFF, 0xE0},
398 {0x112B70, 0xFF, 0x00},
399 {0x112B71, 0xFF, 0xC0},
400
401 {0x112B72, 0xFF, 0x00},
402 {0x112B73, 0xFF, 0x00},
403 {0x112B70, 0xFF, 0x00},
404 {0x112B71, 0xFF, 0xE0},
405 {0x112B70, 0xFF, 0x00},
406 {0x112B71, 0xFF, 0xC0},
407
408 {0x112B72, 0xFF, 0xE9},
409 {0x112B73, 0xFF, 0xFF},
410 {0x112B70, 0xFF, 0xFF},
411 {0x112B71, 0xFF, 0xE3},
412 {0x112B70, 0xFF, 0xFF},
413 {0x112B71, 0xFF, 0xC3},
414
415 {0x112B72, 0xFF, 0x22},
416 {0x112B73, 0xFF, 0x00},
417 {0x112B70, 0xFF, 0x00},
418 {0x112B71, 0xFF, 0xE0},
419 {0x112B70, 0xFF, 0x00},
420 {0x112B71, 0xFF, 0xC0},
421
422 {0x112B72, 0xFF, 0xC5},
423 {0x112B73, 0xFF, 0xFF},
424 {0x112B70, 0xFF, 0xFF},
425 {0x112B71, 0xFF, 0xE3},
426 {0x112B70, 0xFF, 0xFF},
427 {0x112B71, 0xFF, 0xC3},
428
429 {0x112B72, 0xFF, 0x5F},
430 {0x112B73, 0xFF, 0x00},
431 {0x112B70, 0xFF, 0x00},
432 {0x112B71, 0xFF, 0xE0},
433 {0x112B70, 0xFF, 0x00},
434 {0x112B71, 0xFF, 0xC0},
435
436 {0x112B72, 0xFF, 0x6D},
437 {0x112B73, 0xFF, 0xFF},
438 {0x112B70, 0xFF, 0xFF},
439 {0x112B71, 0xFF, 0xE3},
440 {0x112B70, 0xFF, 0xFF},
441 {0x112B71, 0xFF, 0xC3},
442
443 {0x112B72, 0xFF, 0xDA},
444 {0x112B73, 0xFF, 0x00},
445 {0x112B70, 0xFF, 0x00},
446 {0x112B71, 0xFF, 0xE0},
447 {0x112B70, 0xFF, 0x00},
448 {0x112B71, 0xFF, 0xC0},
449
450 {0x112B72, 0xFF, 0xC6},
451 {0x112B73, 0xFF, 0xFE},
452 {0x112B70, 0xFF, 0xFF},
453 {0x112B71, 0xFF, 0xE3},
454 {0x112B70, 0xFF, 0xFF},
455 {0x112B71, 0xFF, 0xC3},
456
457 {0x112B72, 0xFF, 0xB9},
458 {0x112B73, 0xFF, 0x01},
459 {0x112B70, 0xFF, 0x00},
460 {0x112B71, 0xFF, 0xE0},
461 {0x112B70, 0xFF, 0x00},
462 {0x112B71, 0xFF, 0xC0},
463
464 {0x112B72, 0xFF, 0xA0},
465 {0x112B73, 0xFF, 0xFD},
466 {0x112B70, 0xFF, 0xFF},
467 {0x112B71, 0xFF, 0xE3},
468 {0x112B70, 0xFF, 0xFF},
469 {0x112B71, 0xFF, 0xC3},
470
471 {0x112B72, 0xFF, 0x38},
472 {0x112B73, 0xFF, 0x03},
473 {0x112B70, 0xFF, 0x00},
474 {0x112B71, 0xFF, 0xE0},
475 {0x112B70, 0xFF, 0x00},
476 {0x112B71, 0xFF, 0xC0},
477
478 {0x112B72, 0xFF, 0xB6},
479 {0x112B73, 0xFF, 0xFB},
480 {0x112B70, 0xFF, 0xFF},
481 {0x112B71, 0xFF, 0xE3},
482 {0x112B70, 0xFF, 0xFF},
483 {0x112B71, 0xFF, 0xC3},
484
485 {0x112B72, 0xFF, 0xA3},
486 {0x112B73, 0xFF, 0x05},
487 {0x112B70, 0xFF, 0x00},
488 {0x112B71, 0xFF, 0xE0},
489 {0x112B70, 0xFF, 0x00},
490 {0x112B71, 0xFF, 0xC0},
491
492 {0x112B72, 0xFF, 0xAE},
493 {0x112B73, 0xFF, 0xF8},
494 {0x112B70, 0xFF, 0xFF},
495 {0x112B71, 0xFF, 0xE3},
496 {0x112B70, 0xFF, 0xFF},
497 {0x112B71, 0xFF, 0xC3},
498
499 {0x112B72, 0xFF, 0x67},
500 {0x112B73, 0xFF, 0x09},
501 {0x112B70, 0xFF, 0x00},
502 {0x112B71, 0xFF, 0xE0},
503 {0x112B70, 0xFF, 0x00},
504 {0x112B71, 0xFF, 0xC0},
505
506 {0x112B72, 0xFF, 0x0D},
507 {0x112B73, 0xFF, 0xF4},
508 {0x112B70, 0xFF, 0xFF},
509 {0x112B71, 0xFF, 0xE3},
510 {0x112B70, 0xFF, 0xFF},
511 {0x112B71, 0xFF, 0xC3},
512
513 {0x112B72, 0xFF, 0x0B},
514 {0x112B73, 0xFF, 0x0F},
515 {0x112B70, 0xFF, 0x00},
516 {0x112B71, 0xFF, 0xE0},
517 {0x112B70, 0xFF, 0x00},
518 {0x112B71, 0xFF, 0xC0},
519
520 {0x112B72, 0xFF, 0x39},
521 {0x112B73, 0xFF, 0xED},
522 {0x112B70, 0xFF, 0xFF},
523 {0x112B71, 0xFF, 0xE3},
524 {0x112B70, 0xFF, 0xFF},
525 {0x112B71, 0xFF, 0xC3},
526
527 {0x112B72, 0xFF, 0x40},
528 {0x112B73, 0xFF, 0x17},
529 {0x112B70, 0xFF, 0x00},
530 {0x112B71, 0xFF, 0xE0},
531 {0x112B70, 0xFF, 0x00},
532 {0x112B71, 0xFF, 0xC0},
533
534 {0x112B72, 0xFF, 0x6E},
535 {0x112B73, 0xFF, 0xE3},
536 {0x112B70, 0xFF, 0xFF},
537 {0x112B71, 0xFF, 0xE3},
538 {0x112B70, 0xFF, 0xFF},
539 {0x112B71, 0xFF, 0xC3},
540
541 {0x112B72, 0xFF, 0xDE},
542 {0x112B73, 0xFF, 0x22},
543 {0x112B70, 0xFF, 0x00},
544 {0x112B71, 0xFF, 0xE0},
545 {0x112B70, 0xFF, 0x00},
546 {0x112B71, 0xFF, 0xC0},
547
548 {0x112B72, 0xFF, 0xBB},
549 {0x112B73, 0xFF, 0xD5},
550 {0x112B70, 0xFF, 0xFF},
551 {0x112B71, 0xFF, 0xE3},
552 {0x112B70, 0xFF, 0xFF},
553 {0x112B71, 0xFF, 0xC3},
554
555 {0x112B72, 0xFF, 0xEF},
556 {0x112B73, 0xFF, 0x32},
557 {0x112B70, 0xFF, 0x00},
558 {0x112B71, 0xFF, 0xE0},
559 {0x112B70, 0xFF, 0x00},
560 {0x112B71, 0xFF, 0xC0},
561
562 {0x112B72, 0xFF, 0xFB},
563 {0x112B73, 0xFF, 0xC2},
564 {0x112B70, 0xFF, 0xFF},
565 {0x112B71, 0xFF, 0xE3},
566 {0x112B70, 0xFF, 0xFF},
567 {0x112B71, 0xFF, 0xC3},
568
569 {0x112B72, 0xFF, 0xB3},
570 {0x112B73, 0xFF, 0x48},
571 {0x112B70, 0xFF, 0x00},
572 {0x112B71, 0xFF, 0xE0},
573 {0x112B70, 0xFF, 0x00},
574 {0x112B71, 0xFF, 0xC0},
575
576 {0x112B72, 0xFF, 0xD6},
577 {0x112B73, 0xFF, 0xA9},
578 {0x112B70, 0xFF, 0xFF},
579 {0x112B71, 0xFF, 0xE3},
580 {0x112B70, 0xFF, 0xFF},
581 {0x112B71, 0xFF, 0xC3},
582
583 {0x112B72, 0xFF, 0xA1},
584 {0x112B73, 0xFF, 0x65},
585 {0x112B70, 0xFF, 0x00},
586 {0x112B71, 0xFF, 0xE0},
587 {0x112B70, 0xFF, 0x00},
588 {0x112B71, 0xFF, 0xC0},
589
590 {0x112B72, 0xFF, 0xB1},
591 {0x112B73, 0xFF, 0x88},
592 {0x112B70, 0xFF, 0xFF},
593 {0x112B71, 0xFF, 0xE3},
594 {0x112B70, 0xFF, 0xFF},
595 {0x112B71, 0xFF, 0xC3},
596
597 {0x112B72, 0xFF, 0x73},
598 {0x112B73, 0xFF, 0x8B},
599 {0x112B70, 0xFF, 0x00},
600 {0x112B71, 0xFF, 0xE0},
601 {0x112B70, 0xFF, 0x00},
602 {0x112B71, 0xFF, 0xC0},
603
604 {0x112B72, 0xFF, 0xB2},
605 {0x112B73, 0xFF, 0x5D},
606 {0x112B70, 0xFF, 0xFF},
607 {0x112B71, 0xFF, 0xE3},
608 {0x112B70, 0xFF, 0xFF},
609 {0x112B71, 0xFF, 0xC3},
610
611 {0x112B72, 0xFF, 0x28},
612 {0x112B73, 0xFF, 0xBC},
613 {0x112B70, 0xFF, 0x00},
614 {0x112B71, 0xFF, 0xE0},
615 {0x112B70, 0xFF, 0x00},
616 {0x112B71, 0xFF, 0xC0},
617
618 {0x112B72, 0xFF, 0xB2},
619 {0x112B73, 0xFF, 0x26},
620 {0x112B70, 0xFF, 0xFF},
621 {0x112B71, 0xFF, 0xE3},
622 {0x112B70, 0xFF, 0xFF},
623 {0x112B71, 0xFF, 0xC3},
624
625 {0x112B72, 0xFF, 0x11},
626 {0x112B73, 0xFF, 0xFA},
627 {0x112B70, 0xFF, 0x00},
628 {0x112B71, 0xFF, 0xE0},
629 {0x112B70, 0xFF, 0x00},
630 {0x112B71, 0xFF, 0xC0},
631
632 {0x112B72, 0xFF, 0x36},
633 {0x112B73, 0xFF, 0xE1},
634 {0x112B70, 0xFF, 0xFE},
635 {0x112B71, 0xFF, 0xE3},
636 {0x112B70, 0xFF, 0xFE},
637 {0x112B71, 0xFF, 0xC3},
638
639 {0x112B72, 0xFF, 0xD8},
640 {0x112B73, 0xFF, 0x47},
641 {0x112B70, 0xFF, 0x01},
642 {0x112B71, 0xFF, 0xE0},
643 {0x112B70, 0xFF, 0x01},
644 {0x112B71, 0xFF, 0xC0},
645
646 {0x112B72, 0xFF, 0x5C},
647 {0x112B73, 0xFF, 0x8A},
648 {0x112B70, 0xFF, 0xFE},
649 {0x112B71, 0xFF, 0xE3},
650 {0x112B70, 0xFF, 0xFE},
651 {0x112B71, 0xFF, 0xC3},
652
653 {0x112B72, 0xFF, 0x9D},
654 {0x112B73, 0xFF, 0xA8},
655 {0x112B70, 0xFF, 0x01},
656 {0x112B71, 0xFF, 0xE0},
657 {0x112B70, 0xFF, 0x01},
658 {0x112B71, 0xFF, 0xC0},
659
660 {0x112B72, 0xFF, 0xC1},
661 {0x112B73, 0xFF, 0x1E},
662 {0x112B70, 0xFF, 0xFE},
663 {0x112B71, 0xFF, 0xE3},
664 {0x112B70, 0xFF, 0xFE},
665 {0x112B71, 0xFF, 0xC3},
666
667 {0x112B72, 0xFF, 0x10},
668 {0x112B73, 0xFF, 0x20},
669 {0x112B70, 0xFF, 0x02},
670 {0x112B71, 0xFF, 0xE0},
671 {0x112B70, 0xFF, 0x02},
672 {0x112B71, 0xFF, 0xC0},
673
674 {0x112B72, 0xFF, 0x59},
675 {0x112B73, 0xFF, 0x9A},
676 {0x112B70, 0xFF, 0xFD},
677 {0x112B71, 0xFF, 0xE3},
678 {0x112B70, 0xFF, 0xFD},
679 {0x112B71, 0xFF, 0xC3},
680
681 {0x112B72, 0xFF, 0xAB},
682 {0x112B73, 0xFF, 0xB2},
683 {0x112B70, 0xFF, 0x02},
684 {0x112B71, 0xFF, 0xE0},
685 {0x112B70, 0xFF, 0x02},
686 {0x112B71, 0xFF, 0xC0},
687
688 {0x112B72, 0xFF, 0x28},
689 {0x112B73, 0xFF, 0xF8},
690 {0x112B70, 0xFF, 0xFC},
691 {0x112B71, 0xFF, 0xE3},
692 {0x112B70, 0xFF, 0xFC},
693 {0x112B71, 0xFF, 0xC3},
694
695 {0x112B72, 0xFF, 0x07},
696 {0x112B73, 0xFF, 0x66},
697 {0x112B70, 0xFF, 0x03},
698 {0x112B71, 0xFF, 0xE0},
699 {0x112B70, 0xFF, 0x03},
700 {0x112B71, 0xFF, 0xC0},
701
702 {0x112B72, 0xFF, 0xD1},
703 {0x112B73, 0xFF, 0x31},
704 {0x112B70, 0xFF, 0xFC},
705 {0x112B71, 0xFF, 0xE3},
706 {0x112B70, 0xFF, 0xFC},
707 {0x112B71, 0xFF, 0xC3},
708
709 {0x112B72, 0xFF, 0x71},
710 {0x112B73, 0xFF, 0x41},
711 {0x112B70, 0xFF, 0x04},
712 {0x112B71, 0xFF, 0xE0},
713 {0x112B70, 0xFF, 0x04},
714 {0x112B71, 0xFF, 0xC0},
715
716 {0x112B72, 0xFF, 0xDB},
717 {0x112B73, 0xFF, 0x3E},
718 {0x112B70, 0xFF, 0xFB},
719 {0x112B71, 0xFF, 0xE3},
720 {0x112B70, 0xFF, 0xFB},
721 {0x112B71, 0xFF, 0xC3},
722
723 {0x112B72, 0xFF, 0xE3},
724 {0x112B73, 0xFF, 0x4E},
725 {0x112B70, 0xFF, 0x05},
726 {0x112B71, 0xFF, 0xE0},
727 {0x112B70, 0xFF, 0x05},
728 {0x112B71, 0xFF, 0xC0},
729
730 {0x112B72, 0xFF, 0x63},
731 {0x112B73, 0xFF, 0x13},
732 {0x112B70, 0xFF, 0xFA},
733 {0x112B71, 0xFF, 0xE3},
734 {0x112B70, 0xFF, 0xFA},
735 {0x112B71, 0xFF, 0xC3},
736
737 {0x112B72, 0xFF, 0xB9},
738 {0x112B73, 0xFF, 0x9C},
739 {0x112B70, 0xFF, 0x06},
740 {0x112B71, 0xFF, 0xE0},
741 {0x112B70, 0xFF, 0x06},
742 {0x112B71, 0xFF, 0xC0},
743
744 {0x112B72, 0xFF, 0xCB},
745 {0x112B73, 0xFF, 0x9D},
746 {0x112B70, 0xFF, 0xF8},
747 {0x112B71, 0xFF, 0xE3},
748 {0x112B70, 0xFF, 0xF8},
749 {0x112B71, 0xFF, 0xC3},
750
751 {0x112B72, 0xFF, 0xE3},
752 {0x112B73, 0xFF, 0x40},
753 {0x112B70, 0xFF, 0x08},
754 {0x112B71, 0xFF, 0xE0},
755 {0x112B70, 0xFF, 0x08},
756 {0x112B71, 0xFF, 0xC0},
757
758 {0x112B72, 0xFF, 0x4F},
759 {0x112B73, 0xFF, 0xC2},
760 {0x112B70, 0xFF, 0xF6},
761 {0x112B71, 0xFF, 0xE3},
762 {0x112B70, 0xFF, 0xF6},
763 {0x112B71, 0xFF, 0xC3},
764
765 {0x112B72, 0xFF, 0x25},
766 {0x112B73, 0xFF, 0x5F},
767 {0x112B70, 0xFF, 0x0A},
768 {0x112B71, 0xFF, 0xE0},
769 {0x112B70, 0xFF, 0x0A},
770 {0x112B71, 0xFF, 0xC0},
771
772 {0x112B72, 0xFF, 0xF5},
773 {0x112B73, 0xFF, 0x51},
774 {0x112B70, 0xFF, 0xF4},
775 {0x112B71, 0xFF, 0xE3},
776 {0x112B70, 0xFF, 0xF4},
777 {0x112B71, 0xFF, 0xC3},
778
779 {0x112B72, 0xFF, 0x8D},
780 {0x112B73, 0xFF, 0x36},
781 {0x112B70, 0xFF, 0x0D},
782 {0x112B71, 0xFF, 0xE0},
783 {0x112B70, 0xFF, 0x0D},
784 {0x112B71, 0xFF, 0xC0},
785
786 {0x112B72, 0xFF, 0x02},
787 {0x112B73, 0xFF, 0xF6},
788 {0x112B70, 0xFF, 0xF0},
789 {0x112B71, 0xFF, 0xE3},
790 {0x112B70, 0xFF, 0xF0},
791 {0x112B71, 0xFF, 0xC3},
792
793 {0x112B72, 0xFF, 0xE3},
794 {0x112B73, 0xFF, 0x41},
795 {0x112B70, 0xFF, 0x11},
796 {0x112B71, 0xFF, 0xE0},
797 {0x112B70, 0xFF, 0x11},
798 {0x112B71, 0xFF, 0xC0},
799
800 {0x112B72, 0xFF, 0x92},
801 {0x112B73, 0xFF, 0xFA},
802 {0x112B70, 0xFF, 0xEB},
803 {0x112B71, 0xFF, 0xE3},
804 {0x112B70, 0xFF, 0xEB},
805 {0x112B71, 0xFF, 0xC3},
806
807 {0x112B72, 0xFF, 0x09},
808 {0x112B73, 0xFF, 0x94},
809 {0x112B70, 0xFF, 0x17},
810 {0x112B71, 0xFF, 0xE0},
811 {0x112B70, 0xFF, 0x17},
812 {0x112B71, 0xFF, 0xC0},
813
814 {0x112B72, 0xFF, 0xA8},
815 {0x112B73, 0xFF, 0xA4},
816 {0x112B70, 0xFF, 0xE3},
817 {0x112B71, 0xFF, 0xE3},
818 {0x112B70, 0xFF, 0xE3},
819 {0x112B71, 0xFF, 0xC3},
820
821 {0x112B72, 0xFF, 0x9D},
822 {0x112B73, 0xFF, 0x2A},
823 {0x112B70, 0xFF, 0x23},
824 {0x112B71, 0xFF, 0xE0},
825 {0x112B70, 0xFF, 0x23},
826 {0x112B71, 0xFF, 0xC0},
827
828 {0x112B72, 0xFF, 0xC8},
829 {0x112B73, 0xFF, 0x41},
830 {0x112B70, 0xFF, 0xD2},
831 {0x112B71, 0xFF, 0xE3},
832 {0x112B70, 0xFF, 0xD2},
833 {0x112B71, 0xFF, 0xC3},
834
835 {0x112B72, 0xFF, 0xD9},
836 {0x112B73, 0xFF, 0x99},
837 {0x112B70, 0xFF, 0x40},
838 {0x112B71, 0xFF, 0xE0},
839 {0x112B70, 0xFF, 0x40},
840 {0x112B71, 0xFF, 0xC0},
841
842 {0x112B72, 0xFF, 0x5B},
843 {0x112B73, 0xFF, 0xB4},
844 {0x112B70, 0xFF, 0x93},
845 {0x112B71, 0xFF, 0xE3},
846 {0x112B70, 0xFF, 0x93},
847 {0x112B71, 0xFF, 0xC3},
848
849 {0x112B72, 0xFF, 0xC1},
850 {0x112B73, 0xFF, 0xD4},
851 {0x112B70, 0xFF, 0x45},
852 {0x112B71, 0xFF, 0xE1},
853 {0x112B70, 0xFF, 0x45},
854 {0x112B71, 0xFF, 0xC1},
855
856 {0x112B72, 0xFF, 0xE1},
857 {0x112B73, 0xFF, 0xF6},
858 {0x112B70, 0xFF, 0xFF},
859 {0x112B71, 0xFF, 0xE3},
860 {0x112B70, 0xFF, 0xFF},
861 {0x112B71, 0xFF, 0xC3},
862
863 {0x112B72, 0xFF, 0x66},
864 {0x112B73, 0xFF, 0x53},
865 {0x112B70, 0xFF, 0x00},
866 {0x112B71, 0xFF, 0xE0},
867 {0x112B70, 0xFF, 0x00},
868 {0x112B71, 0xFF, 0xC0},
869
870 {0x112B72, 0xFF, 0xEE},
871 {0x112B73, 0xFF, 0x65},
872 {0x112B70, 0xFF, 0xFE},
873 {0x112B71, 0xFF, 0xE3},
874 {0x112B70, 0xFF, 0xFE},
875 {0x112B71, 0xFF, 0xC3},
876
877 {0x112B72, 0xFF, 0xB6},
878 {0x112B73, 0xFF, 0x95},
879 {0x112B70, 0xFF, 0x05},
880 {0x112B71, 0xFF, 0xE0},
881 {0x112B70, 0xFF, 0x05},
882 {0x112B71, 0xFF, 0xC0},
883
884 {0x112B72, 0xFF, 0x50},
885 {0x112B73, 0xFF, 0x72},
886 {0x112B70, 0xFF, 0xF0},
887 {0x112B71, 0xFF, 0xE3},
888 {0x112B70, 0xFF, 0xF0},
889 {0x112B71, 0xFF, 0xC3},
890
891 {0x112B72, 0xFF, 0x9B},
892 {0x112B73, 0xFF, 0xB2},
893 {0x112B70, 0xFF, 0x25},
894 {0x112B71, 0xFF, 0xE0},
895 {0x112B70, 0xFF, 0x25},
896 {0x112B71, 0xFF, 0xC0},
897
898 {0x112B72, 0xFF, 0x1F},
899 {0x112B73, 0xFF, 0x8F},
900 {0x112B70, 0xFF, 0xA6},
901 {0x112B71, 0xFF, 0xE3},
902 {0x112B70, 0xFF, 0xA6},
903 {0x112B71, 0xFF, 0xC3},
904
905 {0x112B72, 0xFF, 0x07},
906 {0x112B73, 0xFF, 0x06},
907 {0x112B70, 0xFF, 0x3F},
908 {0x112B71, 0xFF, 0xE1},
909 {0x112B70, 0xFF, 0x3F},
910 {0x112B71, 0xFF, 0xC1},
911
912 {0x112B72, 0xFF, 0x38},
913 {0x112B73, 0xFF, 0x66},
914 {0x112B70, 0xFF, 0x00},
915 {0x112B71, 0xFF, 0xE0},
916 {0x112B70, 0xFF, 0x00},
917 {0x112B71, 0xFF, 0xC0},
918
919 {0x112B72, 0xFF, 0xC1},
920 {0x112B73, 0xFF, 0x07},
921 {0x112B70, 0xFF, 0xFC},
922 {0x112B71, 0xFF, 0xE3},
923 {0x112B70, 0xFF, 0xFC},
924 {0x112B71, 0xFF, 0xC3},
925
926 {0x112B72, 0xFF, 0x78},
927 {0x112B73, 0xFF, 0xE0},
928 {0x112B70, 0xFF, 0x13},
929 {0x112B71, 0xFF, 0xE0},
930 {0x112B70, 0xFF, 0x13},
931 {0x112B71, 0xFF, 0xC0},
932
933 {0x112B72, 0xFF, 0x3F},
934 {0x112B73, 0xFF, 0x32},
935 {0x112B70, 0xFF, 0xB8},
936 {0x112B71, 0xFF, 0xE3},
937 {0x112B70, 0xFF, 0xB8},
938 {0x112B71, 0xFF, 0xC3},
939
940 {0x112B72, 0xFF, 0x51},
941 {0x112B73, 0xFF, 0x7F},
942 {0x112B70, 0xFF, 0x37},
943 {0x112B71, 0xFF, 0xE1},
944 {0x112B70, 0xFF, 0x37},
945 {0x112B71, 0xFF, 0xC1},
946
947 {0x112B70, 0xFF, 0x00},
948 {0x112B71, 0xFF, 0x80},
949
950 //-----------------AudioBand----------------------------//Item 21
951 {0x112B58, 0xFF, 0xAA}, // DWA fix value
952 {0x112B59, 0xFF, 0xAA},
953 {0x112B57, 0xC0, 0x40}, // DWA fix value
954 {0x112B55, 0xF0, 0xF0}, // DWA fix enable
955
956 {0x112B43, 0xFC, 0xFC}, // Audio Bank Auto recovery enable
957 {0x112BCA, 0xFF, 0x88}, // Group B Synth
958 {0x112BCB, 0xFF, 0x4C},
959 {0x112BC6, 0xFF, 0x88}, // Group B Synth
960 {0x112BC7, 0xFF, 0x4C},
961
962 {0x112BCE, 0x80, 0x00}, // Group B Toggle
963 {0x112BCE, 0x80, 0x80}, // Group B Toggle
964 {0x112BCE, 0x80, 0x00}, // Group B Toggle
965
966 {0x112B40, 0xFF, 0x0E}, // Sram init
967 {0x112B41, 0xFF, 0x00},
968 {0x112B40, 0xFF, 0x4C}, // Sram init
969 {0x112B41, 0xFF, 0x00},
970
971 {0x112B46, 0xFF, 0x00}, // Enable Group C
972 {0x112B47, 0xFF, 0xFF},
973 {0x112B56, 0x30, 0x30}, // Enable ADC1/2
974 {0x112B57, 0xFF, 0x00},
975 {0x112C6E, 0xFF, 0x88}, // Enable Grp A/B
976 {0x112B50, 0xFF, 0x80}, // DC offset value
977 {0x112B51, 0xFF, 0x00},
978 {0x112B10, 0x80, 0x80}, // DC offset value for earphone 9LEVEL SDM
979 {0x112B60, 0xFF, 0xC0},
980 {0x112B61, 0xFF, 0x38},
981 {0x112B62, 0xFF, 0x38},
982 {0x112B63, 0xFF, 0x38},
983
984 {0x112B54, 0xFF, 0x00},// DITHER select 0.5LSB
985 {0x112B55, 0xFF, 0x01},
986 {0x112B52, 0xFF, 0x0F},// DC offset DISABLE, Dither DISABLE
987 {0x112B53, 0xFF, 0xF0},
988 {0x112B40, 0xFF, 0x0C},// Init CODEC SRC
989 {0x112B41, 0xFF, 0x00},
990 {0x112B54, 0x01, 0x01},// SDM EN
991
992 //-----------------SDM RESET----------------------------//Item 33
993 {0x112C00, 0xF0, 0x00},
994 {0x112C00, 0xF0, 0xF0},
995 {0x112C00, 0xF0, 0x00},
996
997 //----------------Audio Reset---------------------------//Item 24
998 {0x112C00, 0xFF, 0x0D},
999 {0x112C01, 0xFF, 0x7F},
1000 {0x112C00, 0xFF, 0x0F},// CLKGEN_RESET
1001 {0x112C01, 0xFF, 0x7F},
1002 {0x112C00, 0xFF, 0x0D},
1003 {0x112C01, 0xFF, 0x7F},
1004 {0x112C00, 0xFF, 0x00},
1005 {0x112C01, 0xFF, 0x00},
1006
1007 //-----------------De-POP_1-----------------------------//Item 25
1008 {0x112CDC, 0xFF, 0xF0}, //wriu -w 0x112cdc 0x3ff0
1009 {0x112CDD, 0xFF, 0x3F},
1010 {0x112CDE, 0xFF, 0x00}, //wriu -w 0x112cde 0x0000
1011 {0x112CDF, 0xFF, 0x00},
1012 {0x112CE6, 0xFF, 0x01}, //wriu -w 0x112ce6 0x0001
1013 {0x112CE7, 0xFF, 0x00},
1014 {0x112CE8, 0xFF, 0x00}, //wriu -w 0x112ce8 0x8000
1015 {0x112CE9, 0xFF, 0x80},
1016 {0x112CE2, 0xFF, 0x01}, //wriu -w 0x112ce2 0x0001
1017 {0x112CE3, 0xFF, 0x00},
1018 {0x112CE0, 0xFF, 0x30}, //wriu -w 0x112ce0 0x1030
1019 {0x112CE1, 0xFF, 0x10},
1020 {0x112CEA, 0xFF, 0x08}, //wriu -w 0x112cea 0x0008
1021 {0x112CEB, 0xFF, 0x00},
1022 {0x112CEE, 0xFF, 0x00}, //wriu -w 0x112cee 0x0000
1023 {0x112CEF, 0xFF, 0x00},
1024 {0x112CEC, 0xFF, 0x00}, //wriu -w 0x112cec 0x0000
1025 {0x112CED, 0xFF, 0x00},
1026
1027 {0x112CDE, 0xFF, 0x00}, //wriu -w 0x112cde 0x7800
1028 {0x112CDF, 0xFF, 0x78},
1029 {0x112CEA, 0xFF, 0x0C}, //wriu -w 0x112cea 0x000c
1030 {0x112CEB, 0xFF, 0x00},
1031 {0x112CEE, 0xFF, 0x81}, //wriu -w 0x112cee 0x1081
1032 {0x112CEF, 0xFF, 0x10},
1033 {0x112CEC, 0xFF, 0xC0}, //wriu -w 0x112cec 0x00c0
1034 {0x112CED, 0xFF, 0x00},
1035
1036 {0x112CDE, 0xFF, 0x00}, //wriu -w 0x112cde 0x7800
1037 {0x112CDF, 0xFF, 0x78},
1038 {0x112CE0, 0xFF, 0x30}, //wriu -w 0x112ce0 0x1030
1039 {0x112CE1, 0xFF, 0x10},
1040 {0x112CE2, 0xFF, 0x00}, //wriu -w 0x112ce2 0x0000
1041 {0x112CE3, 0xFF, 0x00},
1042 {0x112CEC, 0xFF, 0x28}, //wriu -w 0x112cec 0x0028
1043 {0x112CED, 0xFF, 0x00},
1044
1045 {0xFFFFFF, 0x01, 0x01}, //wait 1 //ms
1046
1047 {0x112CDC, 0xFF, 0x00}, //wriu -w 0x112cdc 0x0000 //PD DAC=0
1048 {0x112CDD, 0xFF, 0x00},
1049 {0x112CE6, 0xFF, 0x00}, //wriu -w 0x112ce6 0x0000 //PD_VI=0
1050 {0x112CE7, 0xFF, 0x00},
1051 {0x112CE8, 0xFF, 0x00}, //wriu -w 0x112ce8 0x3000 //PD_VREF=0, EN_VREF_SFTDCH=11
1052 {0x112CE9, 0xFF, 0x30},
1053 {0x112CEA, 0xFF, 0x00}, //wriu -w 0x112cea 0x0000 //PD_OPLP_EAR=0, EN_VMID2GND=0
1054 {0x112CEB, 0xFF, 0x00},
1055
1056 #ifdef CONFIG_MBOOT
1057 {0xFFFFFF, 0x01, 0x30}, // For Mboot power on sequence
1058 #endif
1059 #if 0
1060 #ifndef CONFIG_MBOOT
1061 {0xFFFFFF, 0x01, 0x32}, // Fix preinit audio coming about pop noise to delay 50ms when the STR power on.
1062 #endif
1063 #endif
1064 {0xFFFFFF, 0x00, 0x00}, // end of table
1065 };
1066
1067 const AUDIO_REG_TYPE AudioInitTbl_0[]=
1068 {
1069 //------------------------------------------------------//Item 36
1070 {0x112A80, 0xFF, 0x40},
1071 {0x112A81, 0xFF, 0x00},
1072 {0x112A80, 0xFF, 0x43},
1073 {0x112A81, 0xFF, 0x00},
1074 {0x112A84, 0xFF, 0x5A},
1075 {0x112A85, 0xFF, 0xA0},
1076 {0x112A82, 0xFF, 0x00},
1077 {0x112A83, 0xFF, 0x00},
1078 {0x112A82, 0xFF, 0x80},
1079 {0x112A83, 0xFF, 0x00},
1080
1081 {0x112A80, 0xFF, 0x53},
1082 {0x112A81, 0xFF, 0x00},
1083 {0x112A80, 0xFF, 0x43},
1084 {0x112A81, 0xFF, 0x00},
1085 {0x112A84, 0xFF, 0x5E},
1086 {0x112A85, 0xFF, 0xA0},
1087 {0x112A82, 0xFF, 0x00},
1088 {0x112A83, 0xFF, 0x00},
1089 {0x112A82, 0xFF, 0x80},
1090 {0x112A83, 0xFF, 0x00},
1091
1092 {0x112A80, 0xFF, 0x53},
1093 {0x112A81, 0xFF, 0x00},
1094 {0x112A80, 0xFF, 0x43},
1095 {0x112A81, 0xFF, 0x00},
1096 {0x112A84, 0xFF, 0x62},
1097 {0x112A85, 0xFF, 0xA0},
1098 {0x112A82, 0xFF, 0x00},
1099 {0x112A83, 0xFF, 0x00},
1100 {0x112A82, 0xFF, 0x80},
1101 {0x112A83, 0xFF, 0x00},
1102
1103 {0x112A80, 0xFF, 0x53},
1104 {0x112A81, 0xFF, 0x00},
1105 {0x112A80, 0xFF, 0x43},
1106 {0x112A81, 0xFF, 0x00},
1107 {0x112A84, 0xFF, 0x66},
1108 {0x112A85, 0xFF, 0xA0},
1109 {0x112A82, 0xFF, 0x00},
1110 {0x112A83, 0xFF, 0x00},
1111 {0x112A82, 0xFF, 0x80},
1112 {0x112A83, 0xFF, 0x00},
1113
1114 {0x112A80, 0xFF, 0x53},
1115 {0x112A81, 0xFF, 0x00},
1116 {0x112A80, 0xFF, 0x43},
1117 {0x112A81, 0xFF, 0x00},
1118 {0x112A84, 0xFF, 0x6A},
1119 {0x112A85, 0xFF, 0xA0},
1120 {0x112A82, 0xFF, 0x00},
1121 {0x112A83, 0xFF, 0x00},
1122 {0x112A82, 0xFF, 0x80},
1123 {0x112A83, 0xFF, 0x00},
1124
1125 {0x112A80, 0xFF, 0x53},
1126 {0x112A81, 0xFF, 0x00},
1127 {0x112A80, 0xFF, 0x43},
1128 {0x112A81, 0xFF, 0x00},
1129 {0x112A84, 0xFF, 0x6E},
1130 {0x112A85, 0xFF, 0xA0},
1131 {0x112A82, 0xFF, 0x00},
1132 {0x112A83, 0xFF, 0x00},
1133 {0x112A82, 0xFF, 0x80},
1134 {0x112A83, 0xFF, 0x00},
1135
1136 {0x112A80, 0xFF, 0x53},
1137 {0x112A81, 0xFF, 0x00},
1138 {0x112A80, 0xFF, 0x43},
1139 {0x112A81, 0xFF, 0x00},
1140 {0x112A84, 0xFF, 0x72},
1141 {0x112A85, 0xFF, 0xA0},
1142 {0x112A82, 0xFF, 0x00},
1143 {0x112A83, 0xFF, 0x00},
1144 {0x112A82, 0xFF, 0x80},
1145 {0x112A83, 0xFF, 0x00},
1146
1147 {0x112A80, 0xFF, 0x53},
1148 {0x112A81, 0xFF, 0x00},
1149 {0x112A80, 0xFF, 0x43},
1150 {0x112A81, 0xFF, 0x00},
1151 {0x112A84, 0xFF, 0x76},
1152 {0x112A85, 0xFF, 0xA0},
1153 {0x112A82, 0xFF, 0x00},
1154 {0x112A83, 0xFF, 0x00},
1155 {0x112A82, 0xFF, 0x80},
1156 {0x112A83, 0xFF, 0x00},
1157
1158 {0x112A80, 0xFF, 0x53},
1159 {0x112A81, 0xFF, 0x00},
1160 {0x112A80, 0xFF, 0x43},
1161 {0x112A81, 0xFF, 0x00},
1162 {0x112A84, 0xFF, 0x76},
1163 {0x112A85, 0xFF, 0xA0},
1164 {0x112A82, 0xFF, 0x00},
1165 {0x112A83, 0xFF, 0x00},
1166 {0x112A82, 0xFF, 0x80},
1167 {0x112A83, 0xFF, 0x00},
1168
1169 {0x112A80, 0xFF, 0x53},
1170 {0x112A81, 0xFF, 0x00},
1171 {0x112A80, 0xFF, 0x43},
1172 {0x112A81, 0xFF, 0x00},
1173 {0x112A84, 0xFF, 0x7A},
1174 {0x112A85, 0xFF, 0xA0},
1175 {0x112A82, 0xFF, 0x00},
1176 {0x112A83, 0xFF, 0x00},
1177 {0x112A82, 0xFF, 0x80},
1178 {0x112A83, 0xFF, 0x00},
1179
1180 {0x112A80, 0xFF, 0x53},
1181 {0x112A81, 0xFF, 0x00},
1182 {0x112A80, 0xFF, 0x43},
1183 {0x112A81, 0xFF, 0x00},
1184 {0x112A84, 0xFF, 0x7E},
1185 {0x112A85, 0xFF, 0xA0},
1186 {0x112A82, 0xFF, 0x00},
1187 {0x112A83, 0xFF, 0x00},
1188 {0x112A82, 0xFF, 0x80},
1189 {0x112A83, 0xFF, 0x00},
1190
1191 {0x112A80, 0xFF, 0x53},
1192 {0x112A81, 0xFF, 0x00},
1193 {0x112A80, 0xFF, 0x43},
1194 {0x112A81, 0xFF, 0x00},
1195 {0x112A84, 0xFF, 0x82},
1196 {0x112A85, 0xFF, 0xA0},
1197 {0x112A82, 0xFF, 0x00},
1198 {0x112A83, 0xFF, 0x00},
1199 {0x112A82, 0xFF, 0x80},
1200 {0x112A83, 0xFF, 0x00},
1201
1202 {0x112A80, 0xFF, 0x53},
1203 {0x112A81, 0xFF, 0x00},
1204 {0x112A80, 0xFF, 0x43},
1205 {0x112A81, 0xFF, 0x00},
1206 {0x112A84, 0xFF, 0x86},
1207 {0x112A85, 0xFF, 0xA0},
1208 {0x112A82, 0xFF, 0x00},
1209 {0x112A83, 0xFF, 0x00},
1210 {0x112A82, 0xFF, 0x80},
1211 {0x112A83, 0xFF, 0x00},
1212
1213 {0x112A80, 0xFF, 0x53},
1214 {0x112A81, 0xFF, 0x00},
1215 {0x112A80, 0xFF, 0x43},
1216 {0x112A81, 0xFF, 0x00},
1217 {0x112A84, 0xFF, 0x8A},
1218 {0x112A85, 0xFF, 0xA0},
1219 {0x112A82, 0xFF, 0x00},
1220 {0x112A83, 0xFF, 0x00},
1221 {0x112A82, 0xFF, 0x80},
1222 {0x112A83, 0xFF, 0x00},
1223
1224 {0x112A80, 0xFF, 0x53},
1225 {0x112A81, 0xFF, 0x00},
1226 {0x112A80, 0xFF, 0x43},
1227 {0x112A81, 0xFF, 0x00},
1228 {0x112A84, 0xFF, 0xB5},
1229 {0x112A85, 0xFF, 0xA0},
1230 {0x112A82, 0xFF, 0x00},
1231 {0x112A83, 0xFF, 0x00},
1232 {0x112A82, 0xFF, 0x80},
1233 {0x112A83, 0xFF, 0x00},
1234
1235 {0x112A80, 0xFF, 0x53},
1236 {0x112A81, 0xFF, 0x00},
1237 {0x112A80, 0xFF, 0x43},
1238 {0x112A81, 0xFF, 0x00},
1239 {0x112A84, 0xFF, 0xE0},
1240 {0x112A85, 0xFF, 0xA0},
1241 {0x112A82, 0xFF, 0x00},
1242 {0x112A83, 0xFF, 0x00},
1243 {0x112A82, 0xFF, 0x80},
1244 {0x112A83, 0xFF, 0x00},
1245
1246 {0x112A80, 0xFF, 0x53},
1247 {0x112A81, 0xFF, 0x00},
1248 {0x112A80, 0xFF, 0x43},
1249 {0x112A81, 0xFF, 0x00},
1250 {0x112A80, 0xFF, 0x00},
1251 {0x112A81, 0xFF, 0x00},
1252 {0x112C00, 0xFF, 0x0D},
1253 {0x112C01, 0xFF, 0x7F},
1254 {0x112C00, 0xFF, 0x00},
1255 {0x112C01, 0xFF, 0x00},
1256
1257 {0xFFFFFF, 0x00, 0x00}, // end of table
1258 };
1259
1260 const AUDIO_REG_TYPE AudioInitTbl_1[]=
1261 {
1262 //-----------------De-POP_2-----------------------------//Item 26
1263 {0x112CE0, 0xFF, 0x00}, //wriu -w 0x112ce0 0x0000
1264 {0x112CE1, 0xFF, 0x00},
1265 {0x112CE2, 0xFF, 0x07}, //wriu -w 0x112ce2 0x1001, 0x07 due to avoid same in-mux for ADC1
1266 {0x112CE3, 0xFF, 0x10},
1267
1268 {0x112CE8, 0xFF, 0x00}, //wriu -w 0x112ce8 0x0000 //PD_VREF=0, EN_VREF_SFTDCH=00
1269 {0x112CE9, 0xFF, 0x00},
1270
1271 {0x112CEC, 0xFF, 0x28}, //wriu -w 0x112cec 0x0828 //EN_STG2_LP_EAR=1
1272 {0x112CED, 0xFF, 0x08},
1273 {0x112CEE, 0xFF, 0x01}, //wriu -w 0x112cee 0x1001 //MSP=1, EN_MUTE_EAR=0, SEL_DEPOP_EAR[1:0]=01
1274 {0x112CEF, 0xFF, 0x10},
1275
1276 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
1277 {0x112CEE, 0xFF, 0x01}, //wriu -w 0x112cee 0x1301 //MSP=1,EN_EAR=1,EN_MUTE_EAR=0, SEL_DEPOP_EAR[1:0]=01
1278 {0x112CEF, 0xFF, 0x13},
1279
1280 {0xFFFFFF, 0x01, 0xFA}, // delay 300m sec , for ADC and DAC fast charge delay
1281 {0xFFFFFF, 0x01, 0x32},
1282
1283 {0x112CEE, 0xFF, 0x03}, //wriu -w 0x112cee 0x1303 //MSP=1,EN_EAR=1,EN_MUTE_EAR=0, SEL_DEPOP_EAR[1:0]=11
1284 {0x112CEF, 0xFF, 0x13},
1285
1286 {0xFFFFFF, 0x00, 0x00}, // end of table
1287 };
1288
1289 const AUDIO_REG_TYPE AudioInitTbl_2[]=
1290 {
1291
1292
1293 //-----------------Synthesizer--------------------------//Item 29
1294 {0x112BCF, 0x01, 0x01}, // DVB1 N.F.
1295 {0x112BCE, 0x01, 0x01},
1296 {0x112BA8, 0xFF, 0x94}, // N.f[30:16]
1297 {0x112BA9, 0xFF, 0x11},
1298 {0x112BAA, 0xFF, 0x00},
1299 {0x112BAB, 0xFF, 0x00}, // N.f[15:0]
1300 {0x112C60, 0x80, 0x80},
1301 {0x112BCE, 0x01, 0x00},
1302
1303 {0x112BCF, 0x02, 0x02}, // DVB2 N.F.
1304 {0x112BCE, 0x02, 0x02},
1305 {0x112BAC, 0xFF, 0x94}, // N.f[30:16]
1306 {0x112BAD, 0xFF, 0x11},
1307 {0x112BAE, 0xFF, 0x00}, // N.f[15:0]
1308 {0x112BAF, 0xFF, 0x00},
1309 {0x112C62, 0x80, 0x80},
1310 {0x112BCE, 0x02, 0x00},
1311
1312 {0x112BCF, 0x04, 0x04}, // DVB3 N.F.
1313 {0x112BCE, 0x04, 0x04},
1314 {0x112BB0, 0xFF, 0x94}, // N.f[30:16]
1315 {0x112BB1, 0xFF, 0x11},
1316 {0x112BB2, 0xFF, 0x00}, // N.f[15:0]
1317 {0x112BB3, 0xFF, 0x00},
1318 {0x112C61, 0x80, 0x80},
1319 {0x112BCE, 0x04, 0x00},
1320
1321 {0x112BCF, 0x08, 0x08}, // DVB4 N.F.
1322 {0x112BCE, 0x08, 0x08},
1323 {0x112BB4, 0xFF, 0x94}, // N.f[30:16]
1324 {0x112BB5, 0xFF, 0x11},
1325 {0x112BB6, 0xFF, 0x00}, // N.f[15:0]
1326 {0x112BB7, 0xFF, 0x00},
1327 {0x112C63, 0x80, 0x80},
1328 {0x112BCE, 0x08, 0x00},
1329
1330 {0x112BCF, 0x10, 0x10},// NonPCM
1331 {0x112BCE, 0x20, 0x20},
1332 {0x112BB8, 0xFF, 0x94}, // N.f[30:16]
1333 {0x112BB9, 0xFF, 0x11},
1334 {0x112BBA, 0xFF, 0x00}, // N.f[15:0]
1335 {0x112BBB, 0xFF, 0x00},
1336 {0x112C8B, 0x40, 0x40},
1337 {0x112BCE, 0x20, 0x00},
1338
1339 {0x112BCF, 0x20, 0x20},// NonPCM2
1340 {0x112BCE, 0x10, 0x10},
1341 {0x112BD0, 0xFF, 0x94},
1342 {0x112BD1, 0xFF, 0x11},
1343 {0x112BD2, 0xFF, 0x00},
1344 {0x112BD3, 0xFF, 0x00},
1345 {0x112C5E, 0x40, 0x40},
1346 {0x112BCE, 0x10, 0x00},
1347
1348 {0x112BCF, 0x40, 0x40},// NonPCM3
1349 {0x112BCF, 0x80, 0x80},
1350 {0x112BD6, 0xFF, 0x94},
1351 {0x112BD7, 0xFF, 0x11},
1352 {0x112BD8, 0xFF, 0x00},
1353 {0x112BD9, 0xFF, 0x00},
1354 {0x112C48, 0x80, 0x80},
1355 {0x112BCF, 0x80, 0x00},
1356
1357 {0x112C25, 0x20, 0x20},// DVB5 N.F.
1358 {0x112C25, 0x10, 0x10},
1359 {0x112C26, 0xFF, 0x94}, // N.f[30:16]
1360 {0x112C27, 0xFF, 0x11},
1361 {0x112C28, 0xFF, 0x00}, // N.f[15:0]
1362 {0x112C29, 0xFF, 0x00},
1363 {0x112C25, 0x80, 0x80},
1364 {0x112C25, 0x10, 0x00},
1365
1366 {0x112C25, 0x02, 0x02},// DVB6 N.F.
1367 {0x112C25, 0x01, 0x01},
1368 {0x112C2A, 0xFF, 0x94}, // N.f[30:16]
1369 {0x112C2B, 0xFF, 0x11},
1370 {0x112C2C, 0xFF, 0x00}, // N.f[15:0]
1371 {0x112C2D, 0xFF, 0x00},
1372 {0x112C25, 0x08, 0x08},
1373 {0x112C25, 0x01, 0x00},
1374
1375 {0x112BCF, 0x01, 0x00}, // DVB1 N.F. is contolled by DSP/R2
1376 {0x112BCF, 0x02, 0x00}, // DVB2 N.F. is contolled by DSP/R2
1377 {0x112BCF, 0x04, 0x00}, // DVB3 N.F. is contolled by DSP/R2
1378 {0x112BCF, 0x08, 0x00}, // DVB4 N.F. is contolled by DSP/R2
1379 {0x112C25, 0x20, 0x00}, // DVB5 N.F. is contolled by DSP/R2
1380 {0x112C25, 0x02, 0x00}, // DVB6 N.F. is contolled by DSP/R2
1381
1382 {0x112BCF, 0x10, 0x00}, // NonPCM1 is controlled by DSP/R2
1383 {0x112BCF, 0x20, 0x00}, // NonPCM2 is controlled by DSP/R2
1384 {0x112BCF, 0x40, 0x00}, // NonPCM3 is controlled by DSP/R2
1385
1386 //-----------------Input: HDMI (only Vivaldi side)------//Item 1
1387 {0x112C44, 0xFF, 0x10},// HDMI RX Matrix
1388 {0x112C45, 0xFF, 0x32},
1389 {0x112C46, 0x0F, 0x00},// HDMI RX Switch
1390 {0x112C03, 0x40, 0x40},// AUTO_CLEAR_PC_PD_BAR
1391 {0x112C48, 0x08, 0x08},// HDMI_RX non_pcm_decoder_new_mode
1392 {0x112C48, 0x04, 0x00},// HDMI_RX non_pcm_decoder_fast_lock
1393 {0x112C48, 0x03, 0x00},// HDMI_RX non_pcm_decoder_time_out_sel
1394 {0x112CA4, 0x08, 0x08},// CLK HDMI RX 256FS/128FS EN
1395 {0x112CA4, 0x04, 0x04},// CLK HDMI TX 256FS/128FS EN
1396 {0x112C47, 0x80, 0x00},// disable HDMI non_pcm multi_ch
1397
1398 //-----------------Input: I2S---------------------------//Item 2
1399 {0x112C02, 0xFF, 0x1F},// Enalbe I2S/SIF/SPDIF clock
1400 {0x112C03, 0xFF, 0xC0},
1401 {0x112CAE, 0xFF, 0x0E},// Enalbe I2S/SIF/SPDIF clock
1402 {0x112CAF, 0xFF, 0x40},
1403
1404 //-----------------Input: SPDIF-------------------------//Item 3
1405 {0x112C0A, 0xFF, 0x70}, // SPDIF_IN_CFG
1406 {0x112C0B, 0xFF, 0x13},
1407
1408 //-----------------Input: ADC---------------------------//Item 4
1409 {0x112CDA, 0xFF, 0x2B},
1410 {0x112CDB, 0xFF, 0x03},
1411 {0x112CDA, 0xFF, 0x28}, // [1:0] PD_ADC
1412 {0x112CDB, 0xFF, 0x03},
1413 {0x112CF2, 0xFF, 0x21}, // ADC set invert
1414 {0x112CF3, 0xFF, 0x0F},
1415
1416 //-----------------Decode Path--------------------------//Item 28
1417 {0x112C60, 0xFF, 0x80},// Decoder 1 source from DVB1
1418 {0x112C61, 0xFF, 0x80},// Decoder 3 source from DVB3
1419 {0x112C62, 0xFF, 0x80},// Decoder 2 source from DVB2
1420 {0x112C63, 0xFF, 0x87},// Decoder 4 source from SIF
1421
1422 //-----------------SIF----------------------------------//Item 27
1423 {0x112CB0, 0x60, 0x60},
1424
1425 //-----------------Input: Channel Source----------------//Item 6
1426 {0x112C64, 0xFF, 0x80},// CH1: Source0 , CH5: ADC0
1427 {0x112C65, 0xFF, 0x80},// CH5: default input source = decoder (avoid data output directly before F/W executing SourceSwitch)
1428 {0x112C66, 0xFF, 0x80},// CH2: Source0 , CH6: Source1
1429 {0x112C67, 0xFF, 0x81},
1430 {0x112C68, 0xFF, 0x80},// CH3: Source0 , CH7: Source3
1431 {0x112C69, 0xFF, 0x83},
1432 {0x112C6A, 0xFF, 0x80},// CH4: Source0 , CH8: Source7
1433 {0x112C6B, 0xFF, 0x87},
1434
1435 //-----------------Output: I2S--------------------------//Item 10
1436 {0x163E13, 0x10, 0x10},// I2S out Auto Mode Enable
1437 {0x163E13, 0x0F, 0x03},// I2S out Auto Mode Select
1438 {0x112C90, 0x40, 0x00},
1439 {0x112C90, 0x1E, 0x00},// I2S out OEZ
1440 {0x112C8D, 0x02, 0x00},
1441 {0x112C8D, 0x01, 0x00},
1442 {0x112C8C, 0x70, 0x20},// I2S out MCL Seletc Manual Mode
1443 {0x112C8C, 0x08, 0x00},// I2S out Format
1444 {0x112C8C, 0x07, 0x02},// I2S out bit width Manual Mode
1445 {0x112C8D, 0x80, 0x80},
1446 {0x112C8D, 0x40, 0x40},// I2S out CNT reset
1447 {0x112C8D, 0x08, 0x08},// I2S out FIFO status clear
1448 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
1449 {0x112C8D, 0x40, 0x00},
1450 {0x112C8D, 0x08, 0x00},
1451
1452 //-----------------Output: SPDIF TX1--------------------//Item 11
1453 {0x112C90, 0x01, 0x00},
1454 {0x112C8B, 0x80, 0x80},
1455 {0x112C8B, 0x20, 0x00},
1456 {0x112C8B, 0x10, 0x00},
1457 {0x112C8B, 0x08, 0x00},
1458 {0x112C8B, 0x04, 0x00},
1459 {0x112C8B, 0x02, 0x00},
1460 {0x112C8B, 0x01, 0x00},
1461 {0x112C8A, 0x10, 0x10},
1462 {0x112C8A, 0x08, 0x00},
1463 {0x112C8A, 0x04, 0x00},
1464 {0x112C8A, 0x03, 0x00},
1465 {0x112C8A, 0x80, 0x80},
1466 {0x112C8A, 0x40, 0x40},
1467 {0x112C8A, 0x20, 0x20},
1468 {0xFFFFFF, 0x01, 0x01},// delay 1m sec
1469 {0x112C8A, 0x40, 0x00},
1470 {0x112C8A, 0x20, 0x00},
1471
1472 {0xFFFFFF, 0x00, 0x00}, // end of table
1473 };
1474
1475 const AUDIO_REG_TYPE AudioInitTbl_3[]=
1476 {
1477 //-----------------Output: DAC--------------------------//Item 12
1478 {0xFFFFFF, 0x01, 0x0A},// delay 1m sec
1479 {0x112CEE, 0xFF, 0x03},
1480 {0x112CEF, 0xFF, 0x13},
1481 {0x112CEC, 0xFF, 0x00},
1482 {0x112CED, 0xFF, 0x18},
1483
1484 {0xFFFFFF, 0x00, 0x00}, // end of table
1485 };
1486
1487 const AUDIO_REG_TYPE AudioInitTbl_4[]=
1488 {
1489 //-----------------Output: SPDIF TX2--------------------//Item 13
1490 {0x112C5F, 0x80, 0x80},
1491 {0x112C5F, 0x40, 0x40},
1492 {0x112C5F, 0x20, 0x00},
1493 {0x112C5F, 0x10, 0x00},
1494 {0x112C5F, 0x08, 0x00},
1495 {0x112C5F, 0x04, 0x00},
1496 {0x112C5F, 0x02, 0x00},
1497 {0x112C5F, 0x01, 0x00},
1498 {0x112C5E, 0x10, 0x10}, //enable channal status
1499 {0x112C5E, 0x08, 0x00},
1500 {0x112C5E, 0x04, 0x00},
1501 {0x112C5E, 0x03, 0x00},
1502 {0x112C5E, 0x80, 0x80},
1503 {0x112C5E, 0x40, 0x40},
1504 {0x112C5E, 0x20, 0x20},
1505 {0xFFFFFF, 0x01, 0x01}, // delay 1m sec
1506 {0x112C5E, 0x40, 0x00},
1507 {0x112C5E, 0x20, 0x00},
1508
1509 //-----------------Unsorted-----------------------------//Item 30
1510 {0x112C94, 0xFF, 0x01}, //Enable CH1/5 HW force mute
1511 {0x112C95, 0xFF, 0x01},
1512 {0x112C96, 0xFF, 0x01}, //Enable CH2/6 HW force mute
1513 {0x112C97, 0xFF, 0x01},
1514 {0x112C98, 0xFF, 0x01}, //Enable CH3/7 HW force mute
1515 {0x112C99, 0xFF, 0x01},
1516 {0x112C9A, 0xFF, 0x01}, //Enable CH4/8 HW force mute
1517 {0x112C9B, 0xFF, 0x01},
1518
1519 //-----------------MIU & DMA Setting---------------------------//Item 34
1520 {0x112A44, 0xFF, 0x00}, //maddma fifo addr demeta
1521 {0x112A45, 0xFF, 0x80},
1522 {0x112AC4, 0xFF, 0x00}, //Sedma fifo addr demeta
1523 {0x112AC5, 0xFF, 0x80},
1524 {0x112A21, 0x04, 0x00}, //maddma fifo new mode
1525 {0x112AA1, 0x04, 0x00}, //sedma fifo new mode
1526
1527 {0x163D03, 0x60, 0x20}, // DEC-R2 Use MIU0
1528 {0x163D07, 0x60, 0x20}, // SND-R2 Use MIU0
1529 {0x112940, 0x20, 0x00}, // Enable R2 write buffer burst mode
1530 {0x1129D7, 0x02, 0x02}, // enable R2 dynamic clock gating
1531 {0x163040, 0x20, 0x00}, // Enable R2_1 write buffer burst mode
1532 {0x1630D7, 0x02, 0x02}, // enable R2_1 dynamic clock gating
1533 {0x112AA2, 0x40, 0x40}, // w_IRQ2n select SPDIF_TX
1534 {0x112AA2, 0x10, 0x00}, // w_IRQL1n select SPDIF2 or HDMI_TX
1535 {0x112BE1, 0x01, 0x01}, // w_IRQL1n select SPDIF2
1536 {0x112BE2, 0x20, 0x20}, // w_IRQL1n select SPDIF2
1537 {0x112BE2, 0x40, 0x40}, // w_IRQL1n select SPDIF2
1538 {0x112BE2, 0x10, 0x10}, // w_IRQL1n select SPDIF2
1539
1540 {0x112F60, 0x04, 0x04}, // DMA Arb limit_en
1541 {0x112F62, 0xFF, 0x08}, // DMA Arb Burst Length
1542 {0x112F80, 0xFF, 0x05}, // Cache Arb limit_en
1543 {0x112F81, 0xFF, 0x80},
1544 {0x112F82, 0xFF, 0x08}, // Cache Arb Burst Length
1545 {0x112F83, 0xFF, 0x00},
1546 {0x163D80, 0x04, 0x04}, // R2 Arb limit_en
1547 {0x163D82, 0xFF, 0x08}, // R2 Arb Burst Length
1548 {0x163DA0, 0x04, 0x04}, // R2 Arb limit_en
1549 {0x163DA2, 0xFF, 0x08}, // R2 Arb Burst Length
1550 {0x163E20, 0x04, 0x04}, // DMA Arb limit_en
1551 {0x163E22, 0xFF, 0x08}, // DMA Arb Burst Length
1552
1553 {0xFFFFFF, 0x00, 0x00}, // end of table
1554 };
1555
1556 const AUDIO_REG_TYPE AudioInitTbl_5[]=
1557 {
1558 // ----------------------------------------------------
1559 // sound effect init settings
1560 //-----------------------------------------------------
1561 // if spdif change to mute, need set g_SPDIF_MuteStatus = 1;
1562 {0x112C94, 0x01, 0x01}, // enable CH1 HW force mute @@VVV
1563 {0x112C96, 0x01, 0x01}, // enable CH2 HW force mute @@VVV
1564 {0x112C98, 0x01, 0x01}, // enable CH3 HW force mute @@VVV
1565 {0x112C9A, 0x01, 0x01}, // enable CH4 HW force mute @@VVV
1566 {0x112C95, 0x01, 0x01}, // enable CH5 HW force mute @@VVV
1567 {0x112C97, 0x01, 0x01}, // enable CH6 HW force mute @@VVV
1568 {0x112C99, 0x01, 0x01}, // enable CH7 HW force mute @@VVV
1569
1570 {0x112D01, 0xFF, 0x8C}, // AUOUT0 volume : 0dB ; Mute @@VVV
1571 {0x112D03, 0xFF, 0x8C}, // AUOUT1 volume : 0dB ; Mute @@VVV
1572 {0x112D05, 0xFF, 0x8C}, // AUOUT2 volume : 0dB ; Mute @@VVV
1573 {0x112D07, 0xFF, 0x8C}, // AUOUT3 volume : 0dB ; Mute @@VVV
1574 {0x112D09, 0xFF, 0x8C}, // I2S_OUT volume : 0dB ; Mute @@VVV
1575 {0x112D0B, 0xFF, 0x0C}, // SPDIF_OUT volume : 0dB ; UnMute @@VVV
1576
1577 {0x112D20, 0x80, 0x00}, // Disable EQ @@VVV
1578 {0x112D21, 0xFF, 0xC8}, // Enable Sound effect & tone @@VVV
1579 {0x112D22, 0x3F, 0x3F}, // Enable all output Volume control @@VVV
1580 {0x112D23, 0x01, 0x01}, // Enable SPDIF_OUT volume control @@VVV
1581 {0x112D31, 0x02, 0x00}, // disable SE-DSP power-down command @@VVV
1582
1583 {0x112D50, 0xFF, 0xFF}, // DAC0/1 source default in NULL path @@VVV
1584 {0x112D51, 0xFF, 0xFF}, // DAC2/3 source default in NULL path @@VVV
1585 {0x112D52, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
1586 {0x112D53, 0xFF, 0xFF}, // I2S source default in NULL path @@VVV
1587 {0x112D54, 0xF0, 0x40}, // SRC source from PCM @@VVV
1588
1589 {0x112D59, 0xFF, 0x0C}, // set ch7 volume : 0dB; unmute
1590 {0x112D58, 0xFF, 0x00},
1591 {0x112D5D, 0xFF, 0x0C}, // set mix volume of CH5, CH6, CH8 to 0dB
1592 {0x112D5C, 0xFF, 0x00},
1593 {0x112D5F, 0xFF, 0x0C},
1594 {0x112D5E, 0xFF, 0x00},
1595 {0x112D5B, 0xFF, 0x0C},
1596 {0x112D5A, 0xFF, 0x00},
1597
1598 // ----------------------------------------------------
1599 {0x112B40, 0xFF, 0x4C}, // For Maserati only, dsp control Gain value, default is -1.81db
1600
1601 // ----------------------------------------------------
1602 {0x112A80, 0x80, 0x00}, //idma control by mcu
1603
1604 {0x112E93, 0xFF, 0x00}, // DAP default use downmix channel(0:downmix channel 1:Multi-channel)
1605 {0x112E98, 0xFF, 0x00}, // Multi-channel default volume = 0dB
1606 {0x112E99, 0x7F, 0x0C}, // Multi-channel default volume = 0dB
1607 {0x112C05, 0x01, 0x01}, // dummy reg to check audio init is done
1608 {0xFFFFFF, 0x00, 0x00}, // end of table
1609 };
1610
1611 const AUDIO_REG_TYPE2 ResetDMIOTbl[]=
1612 {
1613 //DMIO a0xx reset
1614
1615 {0x112A80 , 0xFFFF, 0x0040},
1616 {0x112A80 , 0xFFFF, 0x0043},
1617 {0x112a84 , 0xFFFF, 0xa05a},
1618 {0x112a82 , 0xFFFF, 0x0000},
1619 {0x112a82 , 0xFFFF, 0x0080},
1620
1621 {0x112A80 , 0xFFFF, 0x0053},
1622 {0x112A80 , 0xFFFF, 0x0043},
1623 {0x112a84 , 0xFFFF, 0xa05e},
1624 {0x112a82 , 0xFFFF, 0x0000},
1625 {0x112a82 , 0xFFFF, 0x0080},
1626
1627 {0x112a80 , 0xFFFF, 0x0053},
1628 {0x112a80 , 0xFFFF, 0x0043},
1629 {0x112a84 , 0xFFFF, 0xa062},
1630 {0x112a82 , 0xFFFF, 0x0000},
1631 {0x112a82 , 0xFFFF, 0x0080},
1632
1633 {0x112a80 , 0xFFFF, 0x0053},
1634 {0x112a80 , 0xFFFF, 0x0043},
1635 {0x112a84 , 0xFFFF, 0xa066},
1636 {0x112a82 , 0xFFFF, 0x0000},
1637 {0x112a82 , 0xFFFF, 0x0080},
1638
1639 {0x112a80 , 0xFFFF, 0x0053},
1640 {0x112a80 , 0xFFFF, 0x0043},
1641 {0x112a84 , 0xFFFF, 0xa06a},
1642 {0x112a82 , 0xFFFF, 0x0000},
1643 {0x112a82 , 0xFFFF, 0x0080},
1644
1645 {0x112a80 , 0xFFFF, 0x0053},
1646 {0x112a80 , 0xFFFF, 0x0043},
1647 {0x112a84 , 0xFFFF, 0xa06e},
1648 {0x112a82 , 0xFFFF, 0x0000},
1649 {0x112a82 , 0xFFFF, 0x0080},
1650
1651 {0x112a80 , 0xFFFF, 0x0053},
1652 {0x112a80 , 0xFFFF, 0x0043},
1653 {0x112a84 , 0xFFFF, 0xa072},
1654 {0x112a82 , 0xFFFF, 0x0000},
1655 {0x112a82 , 0xFFFF, 0x0080},
1656
1657 {0x112a80 , 0xFFFF, 0x0053},
1658 {0x112a80 , 0xFFFF, 0x0043},
1659 {0x112a84 , 0xFFFF, 0xa076},
1660 {0x112a82 , 0xFFFF, 0x0000},
1661 {0x112a82 , 0xFFFF, 0x0080},
1662
1663 {0x112a80 , 0xFFFF, 0x0053},
1664 {0x112a80 , 0xFFFF, 0x0043},
1665 {0x112a84 , 0xFFFF, 0xa07a},
1666 {0x112a82 , 0xFFFF, 0x0000},
1667 {0x112a82 , 0xFFFF, 0x0080},
1668
1669 {0x112a80 , 0xFFFF, 0x0053},
1670 {0x112a80 , 0xFFFF, 0x0043},
1671 {0x112a84 , 0xFFFF, 0xa07e},
1672 {0x112a82 , 0xFFFF, 0x0000},
1673 {0x112a82 , 0xFFFF, 0x0080},
1674
1675 {0x112a80 , 0xFFFF, 0x0053},
1676 {0x112a80 , 0xFFFF, 0x0043},
1677 {0x112a84 , 0xFFFF, 0xa082},
1678 {0x112a82 , 0xFFFF, 0x0000},
1679 {0x112a82 , 0xFFFF, 0x0080},
1680
1681 {0x112a80 , 0xFFFF, 0x0053},
1682 {0x112a80 , 0xFFFF, 0x0043},
1683 {0x112a84 , 0xFFFF, 0xa086},
1684 {0x112a82 , 0xFFFF, 0x0000},
1685 {0x112a82 , 0xFFFF, 0x0080},
1686
1687 {0x112a80 , 0xFFFF, 0x0053},
1688 {0x112a80 , 0xFFFF, 0x0043},
1689 {0x112a84 , 0xFFFF, 0xa08a},
1690 {0x112a82 , 0xFFFF, 0x0000},
1691 {0x112a82 , 0xFFFF, 0x0080},
1692
1693 {0x112a80 , 0xFFFF, 0x0053},
1694 {0x112a80 , 0xFFFF, 0x0043},
1695 {0x112a84 , 0xFFFF, 0xa0b5},
1696 {0x112a82 , 0xFFFF, 0x0000},
1697 {0x112a82 , 0xFFFF, 0x0080},
1698
1699 {0x112a80 , 0xFFFF, 0x0053},
1700 {0x112a80 , 0xFFFF, 0x0043},
1701 {0x112a84 , 0xFFFF, 0xa0e0},
1702 {0x112a82 , 0xFFFF, 0x0000},
1703 {0x112a82 , 0xFFFF, 0x0080},
1704
1705 {0x112a80 , 0xFFFF, 0x0053},
1706 {0x112a80 , 0xFFFF, 0x0043},
1707 {0x112a80 , 0xFFFF, 0x0000},
1708 {0x112c00 , 0xFFFF, 0x0101},
1709 {0x112c00 , 0xFFFF, 0x0000},
1710
1711 //end DMIO a0xx reset
1712
1713 {0xFFFFFF, 0x0000, 0x0000}, // end of table
1714
1715 };
1716
1717 const AUDIO_REG_TYPE Audio_stopDecTbl[] =
1718 {
1719 {0x160399 , 0xFF, 0x00}, // DEC R2(2R)
1720 {0x16039b , 0xFF, 0x00},
1721 {0x112e99 , 0xFF, 0x00}, // DEC R2(1R)
1722 {0x112e9b , 0xFF, 0x00},
1723 {0x112a2c , 0xFF, 0x00}, // DEC DSP
1724 {0x112aac , 0xFF, 0x00}, // SE DSP
1725
1726 {0xFFFFFF , 0x00, 0x00}, // end of table
1727 };
1728
1729 #if AUDIO_HW_DMA_READER1_SUPPORT
1730 AUDIO_PCM_t Audio_Pcm_HwDma_Reader1 = {
1731 .u8Name = AUDIO_HW_DMA_READER1,
1732 .tPcmOps = {
1733 .open = HAL_AUDIO_PCM_HwDma_Reader1_Open,
1734 .close = HAL_AUDIO_PCM_HwDma_Reader1_Close,
1735 .start = HAL_AUDIO_PCM_HwDma_Reader1_Start,
1736 .stop = HAL_AUDIO_PCM_HwDma_Reader1_Stop,
1737 .set = HAL_AUDIO_PCM_HwDma_Reader1_Set,
1738 .get = HAL_AUDIO_PCM_HwDma_Reader1_Get,
1739 .read = NULL,
1740 .write = HAL_AUDIO_PCM_HwDma_Reader1_Write,
1741 .flush = HAL_AUDIO_PCM_HwDma_Reader1_Flush,
1742 },
1743 .tPcmCaps = {
1744 .u8MultiChFlag = FALSE,
1745 .u8MixingFlag = FALSE,
1746 .u8CaptureFlag = FALSE,
1747 .u32Channel = {1, 2},
1748 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1749 .u32BitWidth = {16},
1750 },
1751 };
1752 #endif
1753
1754 #if AUDIO_HW_DMA_READER2_SUPPORT
1755 AUDIO_PCM_t Audio_Pcm_HwDma_Reader2 = {
1756 .u8Name = AUDIO_HW_DMA_READER2,
1757 .tPcmOps = {
1758 .open = HAL_AUDIO_PCM_HwDma_Reader2_Open,
1759 .close = HAL_AUDIO_PCM_HwDma_Reader2_Close,
1760 .start = HAL_AUDIO_PCM_HwDma_Reader2_Start,
1761 .stop = HAL_AUDIO_PCM_HwDma_Reader2_Stop,
1762 .set = HAL_AUDIO_PCM_HwDma_Reader2_Set,
1763 .get = HAL_AUDIO_PCM_HwDma_Reader2_Get,
1764 .read = NULL,
1765 .write = HAL_AUDIO_PCM_HwDma_Reader2_Write,
1766 .flush = HAL_AUDIO_PCM_HwDma_Reader2_Flush,
1767 },
1768 .tPcmCaps = {
1769 .u8MultiChFlag = FALSE,
1770 .u8MixingFlag = FALSE,
1771 .u8CaptureFlag = FALSE,
1772 .u32Channel = {1, 2},
1773 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1774 .u32BitWidth = {16},
1775 },
1776 };
1777 #endif
1778
1779 #if AUDIO_SW_DMA_READER1_SUPPORT
1780 AUDIO_PCM_t Audio_Pcm_SwDma_Reader1 = {
1781 .u8Name = AUDIO_SW_DMA_READER1,
1782 .tPcmOps = {
1783 .open = HAL_AUDIO_PCM_SwDma_Reader1_Open,
1784 .close = HAL_AUDIO_PCM_SwDma_Reader1_Close,
1785 .start = HAL_AUDIO_PCM_SwDma_Reader1_Start,
1786 .stop = HAL_AUDIO_PCM_SwDma_Reader1_Stop,
1787 .set = HAL_AUDIO_PCM_SwDma_Reader1_Set,
1788 .get = HAL_AUDIO_PCM_SwDma_Reader1_Get,
1789 .read = NULL,
1790 .write = HAL_AUDIO_PCM_SwDma_Reader1_Write,
1791 .flush = HAL_AUDIO_PCM_SwDma_Reader1_Flush,
1792 },
1793 .tPcmCaps = {
1794 .u8MultiChFlag = FALSE,
1795 .u8MixingFlag = FALSE,
1796 .u8CaptureFlag = FALSE,
1797 .u32Channel = {1, 2},
1798 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000},
1799 .u32BitWidth = {16},
1800 },
1801 };
1802 #endif
1803
1804 #if AUDIO_R2_DMA_READER1_SUPPORT
1805 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader1 = {
1806 .u8Name = AUDIO_R2_DMA_READER1,
1807 .tPcmOps = {
1808 .open = HAL_AUDIO_PCM_R2Dma_Reader1_Open,
1809 .close = HAL_AUDIO_PCM_R2Dma_Reader1_Close,
1810 .start = HAL_AUDIO_PCM_R2Dma_Reader1_Start,
1811 .stop = HAL_AUDIO_PCM_R2Dma_Reader1_Stop,
1812 .set = HAL_AUDIO_PCM_R2Dma_Reader1_Set,
1813 .get = HAL_AUDIO_PCM_R2Dma_Reader1_Get,
1814 .read = NULL,
1815 .write = HAL_AUDIO_PCM_R2Dma_Reader1_Write,
1816 .flush = HAL_AUDIO_PCM_R2Dma_Reader1_Flush,
1817 },
1818 .tPcmCaps = {
1819 .u8MultiChFlag = TRUE,
1820 .u8MixingFlag = FALSE,
1821 .u8CaptureFlag = FALSE,
1822 .u32Channel = {1, 2, 10},
1823 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1824 .u32BitWidth = {16},
1825 },
1826 };
1827 #endif
1828
1829 #if AUDIO_R2_DMA_READER2_SUPPORT
1830 AUDIO_PCM_t Audio_Pcm_R2Dma_Reader2 = {
1831 .u8Name = AUDIO_R2_DMA_READER2,
1832 .tPcmOps = {
1833 .open = HAL_AUDIO_PCM_R2Dma_Reader2_Open,
1834 .close = HAL_AUDIO_PCM_R2Dma_Reader2_Close,
1835 .start = HAL_AUDIO_PCM_R2Dma_Reader2_Start,
1836 .stop = HAL_AUDIO_PCM_R2Dma_Reader2_Stop,
1837 .set = HAL_AUDIO_PCM_R2Dma_Reader2_Set,
1838 .get = HAL_AUDIO_PCM_R2Dma_Reader2_Get,
1839 .read = NULL,
1840 .write = HAL_AUDIO_PCM_R2Dma_Reader2_Write,
1841 .flush = HAL_AUDIO_PCM_R2Dma_Reader2_Flush,
1842 },
1843 .tPcmCaps = {
1844 .u8MultiChFlag = TRUE,
1845 .u8MixingFlag = FALSE,
1846 .u8CaptureFlag = FALSE,
1847 .u32Channel = {1, 2, 10},
1848 .u32SampleRate = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000},
1849 .u32BitWidth = {16},
1850 },
1851 };
1852 #endif
1853
1854 #if AUDIO_PCM_CAPTURE1_SUPPORT
1855 AUDIO_PCM_t Audio_Pcm_Capture1 = {
1856 .u8Name = AUDIO_PCM_CAPTURE1,
1857 .tPcmOps = {
1858 .open = HAL_AUDIO_PCM_Capture1_Open,
1859 .close = HAL_AUDIO_PCM_Capture1_Close,
1860 .start = HAL_AUDIO_PCM_Capture1_Start,
1861 .stop = HAL_AUDIO_PCM_Capture1_Stop,
1862 .set = HAL_AUDIO_PCM_Capture1_Set,
1863 .get = HAL_AUDIO_PCM_Capture1_Get,
1864 .read = HAL_AUDIO_PCM_Capture1_Read,
1865 .write = NULL,
1866 .flush = HAL_AUDIO_PCM_Capture1_Flush,
1867 },
1868 .tPcmCaps = {
1869 .u8MultiChFlag = FALSE,
1870 .u8MixingFlag = FALSE,
1871 .u8CaptureFlag = TRUE,
1872 .u32Channel = {2},
1873 .u32SampleRate = {48000},
1874 .u32BitWidth = {16},
1875 },
1876 };
1877 #endif
1878
1879 #if AUDIO_PCM_CAPTURE2_SUPPORT
1880 AUDIO_PCM_t Audio_Pcm_Capture2 = {
1881 .u8Name = AUDIO_PCM_CAPTURE2,
1882 .tPcmOps = {
1883 .open = HAL_AUDIO_PCM_Capture2_Open,
1884 .close = HAL_AUDIO_PCM_Capture2_Close,
1885 .start = HAL_AUDIO_PCM_Capture2_Start,
1886 .stop = HAL_AUDIO_PCM_Capture2_Stop,
1887 .set = HAL_AUDIO_PCM_Capture2_Set,
1888 .get = HAL_AUDIO_PCM_Capture2_Get,
1889 .read = HAL_AUDIO_PCM_Capture2_Read,
1890 .write = NULL,
1891 .flush = HAL_AUDIO_PCM_Capture2_Flush,
1892 },
1893 .tPcmCaps = {
1894 .u8MultiChFlag = FALSE,
1895 .u8MixingFlag = FALSE,
1896 .u8CaptureFlag = TRUE,
1897 .u32Channel = {2},
1898 .u32SampleRate = {48000},
1899 .u32BitWidth = {16},
1900 },
1901 };
1902 #endif
1903
1904 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1905 AUDIO_PCM_t Audio_Pcm_HwDma_Writer1 = {
1906 .u8Name = AUDIO_HW_DMA_WRITER1,
1907 .tPcmOps = {
1908 .open = HAL_AUDIO_PCM_HwDma_Writer1_Open,
1909 .close = HAL_AUDIO_PCM_HwDma_Writer1_Close,
1910 .start = HAL_AUDIO_PCM_HwDma_Writer1_Start,
1911 .stop = HAL_AUDIO_PCM_HwDma_Writer1_Stop,
1912 .set = HAL_AUDIO_PCM_HwDma_Writer1_Set,
1913 .get = HAL_AUDIO_PCM_HwDma_Writer1_Get,
1914 .read = HAL_AUDIO_PCM_HwDma_Writer1_Read,
1915 .write = NULL,
1916 .flush = HAL_AUDIO_PCM_HwDma_Writer1_Flush,
1917 },
1918 .tPcmCaps = {
1919 .u8MultiChFlag = FALSE,
1920 .u8MixingFlag = FALSE,
1921 .u8CaptureFlag = TRUE,
1922 .u32Channel = {2},
1923 .u32SampleRate = {48000},
1924 .u32BitWidth = {16},
1925 },
1926 };
1927 #endif
1928
1929 MS_U8 g_Common_PCM_IO_Init = FALSE;
1930
1931 AUDIO_PCM_t *g_PCM[AUDIO_PCM_MAXNUM] = {
1932 #if AUDIO_HW_DMA_READER1_SUPPORT
1933 &Audio_Pcm_HwDma_Reader1,
1934 #endif
1935 #if AUDIO_HW_DMA_READER2_SUPPORT
1936 &Audio_Pcm_HwDma_Reader2,
1937 #endif
1938 #if AUDIO_SW_DMA_READER1_SUPPORT
1939 &Audio_Pcm_SwDma_Reader1,
1940 #endif
1941 #if AUDIO_R2_DMA_READER1_SUPPORT
1942 &Audio_Pcm_R2Dma_Reader1,
1943 #endif
1944 #if AUDIO_R2_DMA_READER2_SUPPORT
1945 &Audio_Pcm_R2Dma_Reader2,
1946 #endif
1947 #if AUDIO_PCM_CAPTURE1_SUPPORT
1948 &Audio_Pcm_Capture1,
1949 #endif
1950 #if AUDIO_PCM_CAPTURE2_SUPPORT
1951 &Audio_Pcm_Capture2,
1952 #endif
1953 #if AUDIO_HW_DMA_WRITER1_SUPPORT
1954 &Audio_Pcm_HwDma_Writer1,
1955 #endif
1956 };
1957
1958 #if AUDIO_MP3_ENCODER1_SUPPORT
1959 static MS_U32 g_u32Mp3Encoder1RptrOffset = 0;
1960 #endif
1961
1962 #if AUDIO_MP3_ENCODER2_SUPPORT
1963 static MS_U32 g_u32Mp3Encoder2RptrOffset = 0;
1964 #endif
1965
1966
1967 //-------------------------------------------------------------------------------------------------
1968 // Debug Functions
1969 //-------------------------------------------------------------------------------------------------
1970
1971 //-------------------------------------------------------------------------------------------------
1972 // Local Functions
1973 //-------------------------------------------------------------------------------------------------
1974
1975 ////////////////////////////////////////////////////////////////////////////////
1976 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus()
1977 /// @brief \b Function \b Description: Return audio status.
1978 /// @return MS_U16 \b : return structure which include pcm, non pcm, sampling rate.
1979 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus(ST_HDMI_AUDIO_STATUS * p_hdmiAudioSts)1980 MS_BOOL HAL_AUDIO_HDMI_RX_GetHdmiInAudioStatus( ST_HDMI_AUDIO_STATUS *p_hdmiAudioSts)
1981 {
1982 MS_U32 smpRate;
1983 MS_BOOL ret;
1984 ret = true;
1985 if (HAL_AUDIO_HDMI_NonpcmMonitor())
1986 {
1987 switch(HAL_AUDIO_HDMI_DolbyMonitor())
1988 {
1989 case 0x01: p_hdmiAudioSts->audio_type = HDMI_RX_DD; break;
1990 case 0x0b: p_hdmiAudioSts->audio_type = HDMI_RX_DTS; break;
1991 case 0x15: p_hdmiAudioSts->audio_type = HDMI_RX_DDP; break;
1992 default: p_hdmiAudioSts->audio_type = HDMI_RX_Other; break;
1993 }
1994 }
1995 else
1996 p_hdmiAudioSts->audio_type = HDMI_RX_PCM;
1997
1998 if (_AU_AbsRead2Byte(0x101A04)&0x8000)
1999 {
2000 p_hdmiAudioSts->sampleRate = AUDIO_FS_NONE;
2001 ret = false;
2002 }
2003 else
2004 {
2005 smpRate = 216000000/_AU_AbsRead2Byte(0x101A04);
2006
2007 if (smpRate>182400) //192k*0.95
2008 {
2009 p_hdmiAudioSts->sampleRate = AUDIO_FS_192KHZ;
2010 }
2011 else if (smpRate>167200) //176k*0.95
2012 {
2013 p_hdmiAudioSts->sampleRate = AUDIO_FS_176KHZ;
2014 }
2015 else if (smpRate>91200) //92k*0.95
2016 {
2017 p_hdmiAudioSts->sampleRate = AUDIO_FS_96KHZ;
2018 }
2019 else if (smpRate>83600) //88k*0.95
2020 {
2021 p_hdmiAudioSts->sampleRate = AUDIO_FS_88KHZ;
2022 }
2023 else if (smpRate>60800) //64k*0.95
2024 {
2025 p_hdmiAudioSts->sampleRate = AUDIO_FS_64KHZ;
2026 }
2027 else if (smpRate>45600) //48k*0.95
2028 {
2029 p_hdmiAudioSts->sampleRate = AUDIO_FS_48KHZ;
2030 }
2031 else if (smpRate>41800) //44k*0.95
2032 {
2033 p_hdmiAudioSts->sampleRate = AUDIO_FS_44KHZ;
2034 }
2035 else if (smpRate>30400) //32k*0.95
2036 {
2037 p_hdmiAudioSts->sampleRate = AUDIO_FS_32KHZ;
2038 }
2039 else if (smpRate>22800) //24k*0.95
2040 {
2041 p_hdmiAudioSts->sampleRate = AUDIO_FS_24KHZ;
2042 }
2043 else if (smpRate>20900) //22k*0.95
2044 {
2045 p_hdmiAudioSts->sampleRate = AUDIO_FS_22KHZ;
2046 }
2047 else if (smpRate>15200) //16k*0.95
2048 {
2049 p_hdmiAudioSts->sampleRate = AUDIO_FS_16KHZ;
2050 }
2051 else if (smpRate>11400) //12k*0.95
2052 {
2053 p_hdmiAudioSts->sampleRate = AUDIO_FS_12KHZ;
2054 }
2055 else if (smpRate>10450) //11k*0.95
2056 {
2057 p_hdmiAudioSts->sampleRate = AUDIO_FS_11KHZ;
2058 }
2059 else if (smpRate>7600) //8k*0.95
2060 {
2061 p_hdmiAudioSts->sampleRate = AUDIO_FS_8KHZ;
2062 }
2063 else
2064 {
2065 p_hdmiAudioSts->sampleRate = AUDIO_FS_NONE;
2066 }
2067 }
2068 return ret;
2069
2070 }
2071
HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)2072 MS_BOOL HAL_AUDIO_ResetDefaultVars(AUDIO_SHARED_VARS2 * pAUDIOShared)
2073 {
2074 MS_U8 i = 0;
2075 MS_U8 array_mount = 0;
2076
2077 if (pAUDIOShared == NULL)
2078 {
2079 return FALSE;
2080 }
2081
2082 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
2083
2084 /* Fill in default value */
2085 pAUDIOShared->g_DspCodeType = AU_DVB_STANDARD_INVALID;
2086 pAUDIOShared->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
2087 pAUDIOShared->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
2088 pAUDIOShared->g_u8DspAliveFlag = TRUE;
2089 pAUDIOShared->g_eSpdifOutputType = SPDIF_OUT_NONE;
2090 pAUDIOShared->g_SpdifNpcmPath = AUDIO_DSP_ID_ALL;
2091
2092 pAUDIOShared->g_u8SifDspType = DSP_SE;
2093
2094
2095 array_mount = sizeof(pAUDIOShared->sif_gain_0) / sizeof(pAUDIOShared->sif_gain_0[0]);
2096 for (i = 0; i < array_mount; i++)
2097 {
2098 /* Note! sif_gain_0[] is expected same length as sif_shift_0[] */
2099 pAUDIOShared->sif_gain_0[i] = 0x7FFF;
2100 pAUDIOShared->sif_shift_0[i] = 0x0000;
2101 }
2102 pAUDIOShared->g_u8IntTag = 1;
2103 pAUDIOShared->int_mb_cnt = 0;
2104
2105 pAUDIOShared->CompressInfo = 0;
2106 for ( i = 0; i < MAX_AUDIO_BASE_ADDRESS_NUM2; i++ )
2107 {
2108 pAUDIOShared->g_DSPMadMIUBank[i] = g_DSPMadMIUBank[i];
2109 pAUDIOShared->g_DSPBinBaseAddress[i] = g_DSPBinBaseAddress[i];
2110 pAUDIOShared->g_DSPMadBaseBufferAdr[i] = g_DSPMadBaseBufferAdr[i];
2111 pAUDIOShared->g_DSPDDRBinBaseAddress[i] = g_DSPDDRBinBaseAddress[i];
2112 }
2113
2114 pAUDIOShared->eMainSourceType = E_AUDIO_INFO_DTV_IN;
2115 pAUDIOShared->ePrevSourceType = E_AUDIO_INFO_DTV_IN;
2116
2117 pAUDIOShared->eAudioSource = E_AUDIO_INFO_ADC_IN;
2118 pAUDIOShared->eMainAudioSource = AUDIO_NULL_INPUT;
2119 pAUDIOShared->eSubAudioSource = AUDIO_NULL_INPUT;
2120 pAUDIOShared->eScartAudioSource = AUDIO_NULL_INPUT;
2121
2122 pAUDIOShared->g_SPDIF_MuteStatus = 0;
2123
2124 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
2125 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8R2NonPcmSetting = 0x00;
2126 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
2127 pAUDIOShared->stDigitalOutSetting[DIGITAL_SPDIF_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
2128
2129 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
2130 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8R2NonPcmSetting = 0x00;
2131 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
2132 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_ARC_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
2133
2134 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eDigitalOutfMode = DIGITAL_OUT_NONE;
2135 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8R2NonPcmSetting = 0x00;
2136 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].eSourceType = E_AUDIO_INFO_ADC_IN;
2137 pAUDIOShared->stDigitalOutSetting[DIGITAL_HDMI_OUTPUT].u8NonPcmPath = AUDIO_DSP_ID_ALL;
2138
2139 pAUDIOShared->g_dolbyLoudness_DTVsystem = DVB_MODE;
2140 pAUDIOShared->g_dolbyLoudness_Enable = 1;
2141
2142 /* 1st decoder (depends on chip) */
2143 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsVersion = AUD_CAP_VERSION;
2144 pAUDIOShared->AudioCaps[AU_DEC_ID1].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
2145 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum = 2;
2146 pAUDIOShared->AudioCaps[AU_DEC_ID1].u8MaxDmaReaderNum = 2;
2147 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsADSupported = TRUE;
2148 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsPusiDetectSupported = FALSE;
2149 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMpegSupported = TRUE;
2150 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3Supported = TRUE;
2151 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAc3pSupported = TRUE;
2152 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAacSupported = TRUE;
2153 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsMp3Supported = TRUE;
2154 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaSupported = TRUE;
2155 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsRa8LbrSupported = TRUE;
2156 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsXpcmSupported = TRUE;
2157 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsSupported = TRUE;
2158 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsWmaProSupported = TRUE;
2159 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsFlacSupported = TRUE;
2160 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsVorbisSupported = TRUE;
2161 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDtsLbrSupported = TRUE;
2162 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrNbSupported = TRUE;
2163 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsAmrWbSupported = TRUE;
2164 pAUDIOShared->AudioCaps[AU_DEC_ID1].bIsDraSupported = TRUE;
2165
2166 /* 2nd decoder (depends on chip) */
2167 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsVersion = AUD_CAP_VERSION;
2168 pAUDIOShared->AudioCaps[AU_DEC_ID3].u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
2169 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDecoderNum = 2;
2170 pAUDIOShared->AudioCaps[AU_DEC_ID3].u8MaxDmaReaderNum = 2;
2171 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsADSupported = FALSE;
2172 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsPusiDetectSupported = FALSE;
2173 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMpegSupported = TRUE;
2174 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3Supported = TRUE;
2175 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAc3pSupported = TRUE;
2176 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAacSupported = TRUE;
2177 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsMp3Supported = TRUE;
2178 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaSupported = TRUE;
2179 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsRa8LbrSupported = TRUE;
2180 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsXpcmSupported = TRUE;
2181 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsSupported = TRUE;
2182 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsWmaProSupported = TRUE;
2183 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsFlacSupported = TRUE;
2184 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsVorbisSupported = TRUE;
2185 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDtsLbrSupported = TRUE;
2186 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrNbSupported = TRUE;
2187 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsAmrWbSupported = TRUE;
2188 pAUDIOShared->AudioCaps[AU_DEC_ID3].bIsDraSupported = TRUE;
2189
2190 #if defined(MSOS_TYPE_NUTTX)
2191 pAUDIOShared->g_debug_level = AUDIO_DEBUG_LEVEL_WARN;
2192 #elif defined(CONFIG_MBOOT)
2193 pAUDIOShared->g_debug_level = AUDIO_DEBUG_LEVEL_ERROR;
2194 #else
2195 pAUDIOShared->g_debug_level = AUDIO_DEBUG_LEVEL_WARN;
2196 #endif
2197
2198 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructVersion = AUDIO_OUTPUT_DEVICE_SELECTION_VERSION;
2199 pAUDIOShared->g_AudioOutputDeviceSelection.u32StructSize = sizeof(AUDIO_OUTPUT_DEVICE_SELECTION_t);
2200
2201 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructVersion = AUDIO_SPECIFIED_DIGITAL_OUTPUT_VERSION;
2202 pAUDIOShared->g_AudioSpecifiedDigitalOutput.u32StructSize = sizeof(AUDIO_SPECIFIED_DIGITAL_OUTPUT_t);
2203
2204 pAUDIOShared->g_hbr_bypass_enable = FALSE;
2205 return TRUE;
2206 }
2207
HAL_AUDIO_AllocateVars(void)2208 AUDIO_SHARED_VARS2 * HAL_AUDIO_AllocateVars(void)
2209 {
2210 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
2211
2212 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
2213 MS_U32 u32ShmId = 0;
2214 AUDIO_SHARED_VARS2 *virtAddr = 0;
2215 MS_U32 u32BufSize = 0;
2216
2217 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Start %s InitShmFlag=%d\r\n", __FUNCTION__, g_bInitShmFlag);
2218
2219 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == TRUE)
2220 {
2221 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
2222
2223 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s QUERY ClientCounter=%u\r\n", __FUNCTION__, pAUDIOShared->g_u32ClientCounter);
2224
2225 if (pAUDIOShared->g_u32ClientCounter == 0)
2226 {
2227 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Resume from Suspend mode, reset Audio SHM data ...\n");
2228 }
2229 }
2230 else
2231 {
2232 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "create Audio SHM data ...\n");
2233
2234 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_CREATE) == TRUE)
2235 {
2236 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Audio SHM data is created\n");
2237 pAUDIOShared = (AUDIO_SHARED_VARS2 *) virtAddr;
2238
2239 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "reset Audio SHM data ...\n");
2240 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
2241 }
2242 else
2243 {
2244 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "AUDIO SHM allocation failed!\n");
2245 return NULL;
2246 }
2247 }
2248
2249 if (g_bInitShmFlag == FALSE)
2250 {
2251 g_bInitShmFlag = TRUE;
2252 pAUDIOShared->g_u32ClientCounter++;
2253 }
2254
2255 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "End %s InitShmFlag=%d, ClientCounter=%u \r\n", __FUNCTION__, g_bInitShmFlag, pAUDIOShared->g_u32ClientCounter);
2256
2257 #else
2258 pAUDIOShared = &g_audioShared;
2259
2260 if (g_bInitShmFlag == FALSE)
2261 {
2262 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "create Audio SHM data ...\n");
2263 g_bInitShmFlag = TRUE;
2264
2265 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
2266
2267 pAUDIOShared->g_u32ClientCounter++;
2268 }
2269 #endif
2270
2271 gOpenDecodeSystemFuncPtr = HAL_AUDIO_OpenDecodeSystem;
2272 gDigitalOutChannelStatusFuncPtr = HAL_AUDIO_DigitalOut_SetChannelStatus;
2273 pFuncPtr_Setsystem = HAL_AUDIO_SetDecodeSystem;
2274 gGetDDRInfoFuncPtr = HAL_AUDIO_GetDDRInfo;
2275
2276 return pAUDIOShared;
2277 }
2278
HAL_AUDIO_DeAllocateVars(void)2279 MS_BOOL HAL_AUDIO_DeAllocateVars(void)
2280 {
2281 AUDIO_SHARED_VARS2 * pAUDIOShared = NULL;
2282
2283 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
2284 MS_U32 u32ShmId = 0;
2285 AUDIO_SHARED_VARS2 *virtAddr = 0;
2286 MS_U32 u32BufSize = 0;
2287
2288 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Start HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
2289
2290 if (g_bInitShmFlag == TRUE)
2291 {
2292 g_bInitShmFlag = FALSE;
2293
2294 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_SHM_NAME, sizeof(AUDIO_SHARED_VARS2), &u32ShmId, (MS_VIRT *)&virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
2295 {
2296 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : No AUDIO SHM is created!\n", __FUNCTION__);
2297 return FALSE;
2298 }
2299
2300 pAUDIOShared = (AUDIO_SHARED_VARS2 *)virtAddr;
2301 pAUDIOShared->g_u32ClientCounter--;
2302
2303 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "HAL_AUDIO_DeAllocateVars ClientCounter=%u\r\n", pAUDIOShared->g_u32ClientCounter);
2304
2305 if (pAUDIOShared->g_u32ClientCounter == 0)
2306 {
2307 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
2308
2309 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "free Audio SHM data ...\n");
2310 #if defined(MSOS_TYPE_LINUX)
2311 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_SHM_NAME, u32ShmId) == TRUE)
2312 {
2313 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Audio SHM data is freed\n");
2314 }
2315 else
2316 {
2317 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
2318 return FALSE;
2319 }
2320 #endif
2321
2322 HAL_AUDIO_Mutex_DeInit();
2323 }
2324 /* patch for DC off/on no sound issue start */
2325 else
2326 {
2327 HAL_AUDIO_ResetDefaultVars(pAUDIOShared);
2328 }
2329 /* patch for DC off/on no sound issue end */
2330 }
2331
2332 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "End HAL_AUDIO_DeAllocateVars g_bInitShmFlag=%d\r\n", g_bInitShmFlag);
2333 #else
2334 pAUDIOShared = &g_audioShared;
2335
2336 if (g_bInitShmFlag == TRUE)
2337 {
2338 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "free Audio SHM data ...\n");
2339 g_bInitShmFlag = FALSE;
2340
2341 memset(pAUDIOShared, 0x00, sizeof(AUDIO_SHARED_VARS2));
2342 }
2343 #endif
2344
2345 return TRUE;
2346 }
2347
2348 ////////////////////////////////////////////////////////////////////////////////
2349 /// @brief \b Function \b Name: HAL_AUDIO_InitialVars()
2350 /// @brief \b Function \b Description: This routine set audio share memory of Aduio module.
2351 /// @param <IN> \b NONE :
2352 /// @param <OUT> \b NONE :
2353 /// @param <RET> \b NONE :
2354 /// @param <GLOBAL> \b NONE :
2355 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_InitialVars(void)2356 MS_BOOL HAL_AUDIO_InitialVars(void)
2357 {
2358 if (HAL_AUDIO_GET_INIT_FLAG() == FALSE)
2359 {
2360 g_AudioVars2 = HAL_AUDIO_AllocateVars();
2361 if (g_AudioVars2 == NULL)
2362 {
2363 return FALSE;
2364 }
2365
2366 #ifndef MSOS_TYPE_NUTTX
2367 pAudioTeeInfoShm = HAL_AUDIO_AllocateTeeInfoShm();
2368 if (pAudioTeeInfoShm == NULL)
2369 {
2370 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Create Audio TEE INFO SHM data fail...\n");
2371 return FALSE;
2372 }
2373 }
2374 #else
2375 {
2376 MS_U8 audio_mbx_class=0;
2377
2378 MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "MAD", (MS_U8 *)&audio_mbx_class);
2379 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(audio_mbx_class, 10, HAL_AUDIO_HandleDynamicMBX))
2380 {
2381 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD Register MBX MSG error\n");
2382 return FALSE;
2383 }
2384 else
2385 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MAD MBX register msg ok %d\n", audio_mbx_class);
2386
2387 _s32MadEventId = MsOS_CreateEventGroup("MAD_Event");
2388 if (_s32MadEventId < 0)
2389 {
2390 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD CreateEventGroup error....\n");
2391 return FALSE;
2392 }
2393
2394 _s32MadTaskId = MsOS_CreateTask((TaskEntry)_MAD_Proc,
2395 NULL,
2396 E_TASK_PRI_MEDIUM,
2397 TRUE,
2398 NULL,
2399 32, // stack size..
2400 "MAD_ISR_Task");
2401 if (_s32MadTaskId < 0)
2402 {
2403 MsOS_DeleteEventGroup(_s32MadEventId);
2404 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "MAD CreateTask error....\n");
2405 return FALSE;
2406 }
2407 }
2408 }
2409 #endif
2410
2411 return TRUE;
2412 }
2413
2414 ////////////////////////////////////////////////////////////////////////////////
2415 /// @brief \b Function \b Name: HAL_AUDIO_DeInitialVars()
2416 /// @brief \b Function \b Description: This routine delete audio share memory of Aduio module.
2417 /// @param <IN> \b NONE :
2418 /// @param <OUT> \b NONE :
2419 /// @param <RET> \b NONE :
2420 /// @param <GLOBAL> \b NONE :
2421 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DeInitialVars(void)2422 MS_BOOL HAL_AUDIO_DeInitialVars(void)
2423 {
2424 MS_BOOL ret = TRUE;
2425
2426 if (HAL_AUDIO_GET_INIT_FLAG() == TRUE)
2427 {
2428 HAL_AUDIO_SET_INIT_FLAG(FALSE);
2429
2430 ret = HAL_AUDIO_DeAllocateVars();
2431 if (ret == FALSE)
2432 {
2433 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO SHM de-allocation failed!\n", __FUNCTION__);
2434 }
2435
2436 #if 0 /* patch for STR resume segmentation fault issue */
2437 g_AudioVars2 = NULL;
2438 #endif
2439
2440 #ifndef MSOS_TYPE_NUTTX
2441 {
2442 MS_BOOL ret1;
2443
2444 ret1 = HAL_AUDIO_DeAllocateTeeInfoShm();
2445 if (ret1 == FALSE)
2446 {
2447 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
2448 ret = FALSE;
2449 }
2450 }
2451 #endif
2452 }
2453
2454 return ret;
2455 }
2456
2457 ////////////////////////////////////////////////////////////////////////////////
2458 /// @brief \b Function \b Name: HAL_AUDIO_SET_INIT_FLAG()
2459 /// @brief \b Function \b Description: This routine set the initial status of Aduio module.
2460 /// @param <IN> \b NONE :
2461 /// @param <OUT> \b NONE :
2462 /// @param <RET> \b MS_BOOL :
2463 /// @param <GLOBAL> \b NONE :
2464 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)2465 void HAL_AUDIO_SET_INIT_FLAG(MS_BOOL bSet)
2466 {
2467 HALAUDIO_CHECK_SHM_INIT;
2468
2469 g_AudioVars2->g_Audio_InitFlag = bSet;
2470
2471 return;
2472 }
2473
2474 ////////////////////////////////////////////////////////////////////////////////
2475 /// @brief \b Function \b Name: HAL_AUDIO_GET_INIT_FLAG()
2476 /// @brief \b Function \b Description: This routine get the initial status of Aduio module.
2477 /// @param <IN> \b NONE :
2478 /// @param <OUT> \b NONE :
2479 /// @param <RET> \b MS_BOOL :
2480 /// @param <GLOBAL> \b NONE :
2481 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GET_INIT_FLAG(void)2482 MS_BOOL HAL_AUDIO_GET_INIT_FLAG(void)
2483 {
2484 if (g_AudioVars2 == NULL)
2485 {
2486 return FALSE;
2487 }
2488
2489 return g_AudioVars2->g_Audio_InitFlag;
2490 }
2491
2492 ////////////////////////////////////////////////////////////////////////////////
2493 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_Init()
2494 /// @brief \b Function \b Description: This routine is the initialization of Mutex for Audio module.
2495 /// @param <IN> \b NONE :
2496 /// @param <OUT> \b NONE :
2497 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
2498 /// @param <GLOBAL> \b NONE :
2499 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_Init(void)2500 MS_BOOL HAL_AUDIO_Mutex_Init(void)
2501 {
2502 MS_BOOL ret = TRUE;
2503
2504 if ((_s32AUDIOMutex != -1) &&
2505 (_s32AUDIOMutexReboot != -1) &&
2506 (_s32MutexLoadCode != -1) &&
2507 (_s32AUDIOMutexIDMA != -1))
2508 {
2509 return ret;
2510 }
2511
2512 if (_s32AUDIOMutex == -1)
2513 {
2514 _s32AUDIOMutex = OS_CREATE_MUTEX(AUDIO);
2515 if (_s32AUDIOMutex == -1)
2516 {
2517 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex failed!\n");
2518 ret = FALSE;
2519 }
2520 }
2521
2522 if (_s32AUDIOMutexReboot == -1)
2523 {
2524 _s32AUDIOMutexReboot = OS_CREATE_MUTEX(AUDIOreboot);
2525 if (_s32AUDIOMutexReboot == -1)
2526 {
2527 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for Reboot failed!\n");
2528 ret = FALSE;
2529 }
2530 }
2531
2532 if (_s32MutexLoadCode == -1)
2533 {
2534 _s32MutexLoadCode = OS_CREATE_MUTEX(LOAD_DECDSP);
2535 if (_s32MutexLoadCode == -1)
2536 {
2537 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for Load DSP failed!\n");
2538 ret = FALSE;
2539 }
2540 }
2541
2542 if (_s32AUDIOMutexIDMA == -1)
2543 {
2544 _s32AUDIOMutexIDMA = OS_CREATE_MUTEX(AUDIO_IDMA);
2545 if (_s32AUDIOMutexIDMA == -1)
2546 {
2547 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Create Mutex for IMDA failed!\n");
2548 ret = FALSE;
2549 }
2550 }
2551
2552 if (ret == FALSE)
2553 {
2554 if (_s32AUDIOMutex != -1)
2555 {
2556 OS_DELETE_MUTEX(_s32AUDIOMutex);
2557 _s32AUDIOMutex = -1;
2558 }
2559
2560 if (_s32AUDIOMutexReboot != -1)
2561 {
2562 OS_DELETE_MUTEX(_s32AUDIOMutexReboot);
2563 _s32AUDIOMutexReboot = -1;
2564 }
2565
2566 if (_s32MutexLoadCode != -1)
2567 {
2568 OS_DELETE_MUTEX(_s32MutexLoadCode);
2569 _s32MutexLoadCode = -1;
2570 }
2571
2572 if (_s32AUDIOMutexIDMA != -1)
2573 {
2574 OS_DELETE_MUTEX(_s32AUDIOMutexIDMA);
2575 _s32AUDIOMutexIDMA = -1;
2576 }
2577 }
2578
2579 return ret;
2580 }
2581
2582 ////////////////////////////////////////////////////////////////////////////////
2583 /// @brief \b Function \b Name: HAL_AUDIO_Mutex_DeInit()
2584 /// @brief \b Function \b Description: This routine is the deletion of Mutex for Audio module.
2585 /// @param <IN> \b NONE :
2586 /// @param <OUT> \b NONE :
2587 /// @param <RET> \b MS_BOOL : TRUE - Success, FALSE - Fail
2588 /// @param <GLOBAL> \b NONE :
2589 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Mutex_DeInit(void)2590 MS_BOOL HAL_AUDIO_Mutex_DeInit(void)
2591 {
2592 MS_BOOL ret = TRUE;
2593
2594 if ((_s32AUDIOMutex == -1) &&
2595 (_s32AUDIOMutexReboot == -1) &&
2596 (_s32MutexLoadCode == -1) &&
2597 (_s32AUDIOMutexIDMA == -1))
2598 {
2599 return ret;
2600 }
2601
2602 if (_s32AUDIOMutex != -1)
2603 {
2604 if (OS_DELETE_MUTEX(_s32AUDIOMutex) != TRUE)
2605 {
2606 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex failed!\n");
2607 ret = FALSE;
2608 }
2609 _s32AUDIOMutex = -1;
2610 }
2611
2612 if (_s32AUDIOMutexReboot != -1)
2613 {
2614 if (OS_DELETE_MUTEX(_s32AUDIOMutexReboot) != TRUE)
2615 {
2616 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for Reboot failed!\n");
2617 ret = FALSE;
2618 }
2619 _s32AUDIOMutexReboot = -1;
2620 }
2621
2622 if (_s32MutexLoadCode != -1)
2623 {
2624 if (OS_DELETE_MUTEX(_s32MutexLoadCode) != TRUE)
2625 {
2626 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for Load DSP failed!\n");
2627 ret = FALSE;
2628 }
2629 _s32MutexLoadCode = -1;
2630 }
2631
2632 if (_s32AUDIOMutexIDMA != -1)
2633 {
2634 if (OS_DELETE_MUTEX(_s32AUDIOMutexIDMA) != TRUE)
2635 {
2636 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Error! Delete Mutex for IMDA failed!\n");
2637 ret = FALSE;
2638 }
2639 _s32AUDIOMutexIDMA = -1;
2640 }
2641
2642 return ret;
2643 }
2644
2645 ////////////////////////////////////////////////////////////////////////////////
2646 /// @brief \b Function \b Name: HAL_AUDIO_GetChipType() @@Cathy
2647 /// @brief \b Function \b Description: This routine is used to get the IC version for API.
2648 /// @param <IN> \b NONE :
2649 /// @param <OUT> \b NONE :
2650 /// @param <RET> \b AU_CHIP_TYPE :
2651 /// @param <GLOBAL> \b NONE :
2652 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetChipType(void)2653 AU_CHIP_TYPE HAL_AUDIO_GetChipType(void)
2654 {
2655 return AU_CHIP_MONACO;
2656 }
2657
2658 ////////////////////////////////////////////////////////////////////////////////
2659 /// @brief \b Function \b Name: HAL_AUDIO_Set_MMIO_BASE() @@Cathy
2660 /// @brief \b Function \b Description: This routine is used to set MMIO base
2661 /// @param <IN> \b u32_MMIO_MapBase :
2662 /// @param <OUT> \b NONE :
2663 /// @param <RET> \b :
2664 /// @param <GLOBAL> \b NONE :
2665 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)2666 void HAL_AUDIO_Set_MMIO_BASE(MS_VIRT _MMIO_MapBase)
2667 {
2668 _gMIO_MapBase = _MMIO_MapBase; // Get the absolute MMIO address
2669 }
2670
2671 //-------------------------------------------------------------------------------------------------
2672 // Global Functions
2673 //-------------------------------------------------------------------------------------------------
2674
2675 ////////////////////////////////////////////////////////////////////////////////
2676 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadByte @@Cathy
2677 /// @brief \b Function \b Description: read 1 Byte data
2678 /// @param <IN> \b u32RegAddr: register address
2679 /// @param <OUT> \b None :
2680 /// @param <RET> \b MS_U8 : 8-bit register value
2681 /// @param <GLOBAL> \b None :
2682 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)2683 MS_U8 HAL_AUDIO_AbsReadByte(MS_U32 u32RegAddr)
2684 {
2685 return (_AU_AbsReadByte((u32RegAddr-0x100000)));
2686 }
2687
2688 ////////////////////////////////////////////////////////////////////////////////
2689 /// @brief \b Function \b Name: HAL_AUDIO_ReadByte @@Cathy
2690 /// @brief \b Function \b Description: read 1 Byte data
2691 /// @param <IN> \b u32RegAddr: register address
2692 /// @param <OUT> \b None :
2693 /// @param <RET> \b MS_U8 : 8-bit register value
2694 /// @param <GLOBAL> \b None :
2695 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)2696 MS_U8 HAL_AUDIO_ReadByte(MS_U32 u32RegAddr)
2697 {
2698 return (_AU_AbsReadByte(u32RegAddr+0x010000)); // Add audio bank offset
2699 }
2700
2701
2702 ////////////////////////////////////////////////////////////////////////////////
2703 /// @brief \b Function \b Name: HAL_AUDIO_AbsReadReg @@Cathy
2704 /// @brief \b Function \b Description: read 2 Byte data
2705 /// @param <IN> \b u32RegAddr: register address
2706 /// @param <OUT> \b None :
2707 /// @param <RET> \b MS_U16 : 16-bit register value
2708 /// @param <GLOBAL> \b None :
2709 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)2710 MS_U16 HAL_AUDIO_AbsReadReg(MS_U32 u32RegAddr)
2711 {
2712 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2713 return _AU_AbsRead2Byte((u32RegAddr-0x100000)); // Add audio bank offset
2714 }
2715
2716 ////////////////////////////////////////////////////////////////////////////////
2717 /// @brief \b Function \b Name: HAL_AUDIO_ReadReg @@Cathy
2718 /// @brief \b Function \b Description: read 2 Byte data
2719 /// @param <IN> \b u32RegAddr: register address
2720 /// @param <OUT> \b None :
2721 /// @param <RET> \b MS_U16 : 16-bit register value
2722 /// @param <GLOBAL> \b None :
2723 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)2724 MS_U16 HAL_AUDIO_ReadReg(MS_U32 u32RegAddr)
2725 {
2726 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2727 return (_AU_AbsRead2Byte(u32RegAddr+0x010000)); // Add audio bank offset
2728 }
2729
2730 ////////////////////////////////////////////////////////////////////////////////
2731 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteReg
2732 /// @brief \b Function \b Description: write 2 Byte data
2733 /// @param <IN> \b u32RegAddr: register address
2734 /// @param <IN> \b u16Val : 2 byte data
2735 /// @param <OUT> \b None :
2736 /// @param <RET> \b None :
2737 /// @param <GLOBAL> \b None :
2738 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2739 void HAL_AUDIO_AbsWriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2740 {
2741 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2742 _AU_AbsWrite2Byte((u32RegAddr-0x100000),u16Val); // Add audio bank offset
2743 }
2744
2745 ////////////////////////////////////////////////////////////////////////////////
2746 /// @brief \b Function \b Name: HAL_AUDIO_WriteReg @@Cathy
2747 /// @brief \b Function \b Description: write 2 Byte data
2748 /// @param <IN> \b u32RegAddr: register address
2749 /// @param <IN> \b u16Val : 2 byte data
2750 /// @param <OUT> \b None :
2751 /// @param <RET> \b None :
2752 /// @param <GLOBAL> \b None :
2753 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteReg(MS_U32 u32RegAddr,MS_U16 u16Val)2754 void HAL_AUDIO_WriteReg(MS_U32 u32RegAddr, MS_U16 u16Val)
2755 {
2756 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2757 _AU_AbsWrite2Byte((u32RegAddr+0x010000),u16Val); // Add audio bank offset
2758 }
2759
2760 ////////////////////////////////////////////////////////////////////////////////
2761 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteByte
2762 /// @brief \b Function \b Description: write 1 Byte data
2763 /// @param <IN> \b u32RegAddr: register address
2764 /// @param <IN> \b u8Val : 1 byte data
2765 /// @param <OUT> \b None :
2766 /// @param <RET> \b None :
2767 /// @param <GLOBAL> \b None :
2768 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2769 void HAL_AUDIO_AbsWriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2770 {
2771 _AU_AbsWriteByte((u32RegAddr-0x100000), u8Val); // Add audio bank offset
2772 }
2773
2774 ////////////////////////////////////////////////////////////////////////////////
2775 /// @brief \b Function \b Name: HAL_AUDIO_WriteByte @@Cathy
2776 /// @brief \b Function \b Description: write 1 Byte data
2777 /// @param <IN> \b u32RegAddr: register address
2778 /// @param <IN> \b u8Val : 1 byte data
2779 /// @param <OUT> \b None :
2780 /// @param <RET> \b None :
2781 /// @param <GLOBAL> \b None :
2782 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)2783 void HAL_AUDIO_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
2784 {
2785 _AU_AbsWriteByte((u32RegAddr+0x010000), u8Val); // Add audio bank offset
2786 }
2787
2788 ////////////////////////////////////////////////////////////////////////////////
2789 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskByte @@Morris
2790 /// @brief \b Function \b Description: Mask write 8-bit data
2791 /// @param <IN> \b u32RegAddr: register address
2792 /// @param <IN> \b u16Val : 8-bit data
2793 /// @param <OUT> \b None :
2794 /// @param <RET> \b None :
2795 /// @param <GLOBAL> \b None :
2796 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2797 void HAL_AUDIO_AbsWriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2798 {
2799 _AU_AbsWriteMaskByte((u32RegAddr-0x100000), u8Mask, u8Val);
2800 }
2801
2802 ////////////////////////////////////////////////////////////////////////////////
2803 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskByte @@Cathy
2804 /// @brief \b Function \b Description: Mask write 8-bit data
2805 /// @param <IN> \b u32RegAddr: register address
2806 /// @param <IN> \b u16Val : 8-bit data
2807 /// @param <OUT> \b None :
2808 /// @param <RET> \b None :
2809 /// @param <GLOBAL> \b None :
2810 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_U8 u8Val)2811 void HAL_AUDIO_WriteMaskByte(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_U8 u8Val)
2812 {
2813 _AU_AbsWriteMaskByte((u32RegAddr+0x010000), u8Mask, u8Val); // Add audio bank offset
2814 }
2815
2816 ////////////////////////////////////////////////////////////////////////////////
2817 /// @brief \b Function \b Name: HAL_AUDIO_AbsWriteMaskReg
2818 /// @brief \b Function \b Description: Mask write 16-bit data
2819 /// @param <IN> \b u32RegAddr: register address
2820 /// @param <IN> \b u16Val : 16-bit data
2821 /// @param <OUT> \b None :
2822 /// @param <RET> \b None :
2823 /// @param <GLOBAL> \b None :
2824 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2825 void HAL_AUDIO_AbsWriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2826 {
2827 MS_U16 u16RegVal;
2828
2829 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2830 u16RegVal = _AU_AbsRead2Byte((u32RegAddr-0x100000));
2831 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2832 _AU_AbsWrite2Byte((u32RegAddr-0x100000), u16RegVal);
2833 }
2834
2835 ////////////////////////////////////////////////////////////////////////////////
2836 /// @brief \b Function \b Name: HAL_AUDIO_WriteMaskReg @@Cathy
2837 /// @brief \b Function \b Description: Mask write 16-bit data
2838 /// @param <IN> \b u32RegAddr: register address
2839 /// @param <IN> \b u16Val : 16-bit data
2840 /// @param <OUT> \b None :
2841 /// @param <RET> \b None :
2842 /// @param <GLOBAL> \b None :
2843 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr,MS_U16 u16Mask,MS_U16 u16Val)2844 void HAL_AUDIO_WriteMaskReg(MS_U32 u32RegAddr, MS_U16 u16Mask, MS_U16 u16Val)
2845 {
2846 MS_U16 u16RegVal;
2847
2848 u32RegAddr = (u32RegAddr & 0xFFFFFFFE); // Reg Address must be even
2849 u16RegVal = HAL_AUDIO_ReadReg(u32RegAddr);
2850 u16RegVal = ((u16RegVal & (~(u16Mask))) | (u16Val & u16Mask));
2851 HAL_AUDIO_WriteReg(u32RegAddr, u16RegVal);
2852 }
2853
2854 ////////////////////////////////////////////////////////////////////////////////
2855 /// @brief \b Function \b Name: _HAL_AUDIO_Write4Byte @@Cathy
2856 /// @brief \b Function \b Description: write 4 Byte data
2857 /// @param <IN> \b u32RegAddr: register address
2858 /// @param <IN> \b u32Val : 4 byte data
2859 /// @param <OUT> \b None :
2860 /// @param <RET> \b None :
2861 /// @param <GLOBAL> \b None :
2862 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)2863 void _HAL_AUDIO_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
2864 {
2865 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+0x010000] =(MS_U16) (u32Val&0xFFFF);
2866 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr+2+0x010000] =(MS_U16) (u32Val>>16);
2867 }
2868
2869 ////////////////////////////////////////////////////////////////////////////////
2870 /// @brief \b Function \b Name: HAL_AUDIO_ReadMailBox() @@Need_Modify
2871 /// @brief \b Function \b Description: This routine is used to read the Dec or SE DSP mail box value
2872 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2873 /// @param <IN> \b u8ParamNum : Mail box address
2874 /// @param <OUT> \b NONE :
2875 /// @param <RET> \b U16 : Mail Box value
2876 /// @param <GLOBAL> \b NONE :
2877 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum)2878 MS_U16 HAL_AUDIO_ReadMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum)
2879 {
2880 MS_U16 u16Tmp1, u16Tmp2;
2881 MS_U32 i, u32MailReg;
2882
2883
2884 for (i=0; i<1000; i++)
2885 {
2886 if(bDspType==DSP_SE)
2887 {
2888 if(u8ParamNum<8)
2889 {
2890 u32MailReg = 0x2D70+(MS_U32)u8ParamNum * 2;
2891 }
2892 else
2893 {
2894 u32MailReg = REG_SE_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2895 }
2896 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2897 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2898 }
2899 else
2900 {
2901 if(u8ParamNum<8)
2902 {
2903 u32MailReg = 0x2D60+(MS_U32)u8ParamNum * 2;
2904 }
2905 else
2906 {
2907 u32MailReg = REG_DEC_D2M_MAIL_BOX_BASE+(MS_U32)(u8ParamNum-8) * 2;
2908 }
2909 u16Tmp1 = HAL_AUDIO_ReadReg(u32MailReg);
2910 u16Tmp2 = HAL_AUDIO_ReadReg(u32MailReg);
2911 }
2912 if(u16Tmp1==u16Tmp2)
2913 {
2914 return u16Tmp1;
2915 }
2916 }
2917
2918 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "Read Mailbox fail! \r\n");
2919 return 0;
2920
2921 }
2922
2923 ////////////////////////////////////////////////////////////////////////////////
2924 /// @brief \b Function \b Name: HAL_AUDIO_WriteDecMailBox() @@Need_Modify
2925 /// @brief \b Function \b Description: This routine is used to write Dec-DSP mail box
2926 /// @param <IN> \b bDspType : 0 --DEC 1 -- SE
2927 /// @param <IN> \b u8ParamNum : Mail box address
2928 /// @param <IN> \b u16Data : value
2929 /// @param <OUT> \b NONE :
2930 /// @param <RET> \b NONE :
2931 /// @param <GLOBAL> \b NONE :
2932 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteMailBox(MS_BOOL bDspType,MS_U8 u8ParamNum,MS_U16 u16Data)2933 void HAL_AUDIO_WriteMailBox(MS_BOOL bDspType, MS_U8 u8ParamNum, MS_U16 u16Data)
2934 {
2935 MS_U32 u32MailReg;
2936
2937 if(bDspType==DSP_SE)
2938 {
2939 u32MailReg = REG_SE_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2940 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2941 }
2942 else
2943 {
2944 u32MailReg = REG_DEC_M2D_MAIL_BOX_BASE + (MS_U32)u8ParamNum* 2;
2945 HAL_AUDIO_WriteReg(u32MailReg, u16Data);
2946 }
2947 }
2948
2949
2950 ///-----------------------------------------------------------------------------
2951 ////////////////////////////////////////////////////////////////////////////////
2952 ////////////////////////////////////////////////////////////////////////////////
2953 ///
2954 /// AUDIO Initialize Relational Hal Function
2955 ///
2956 ////////////////////////////////////////////////////////////////////////////////
2957
2958 ////////////////////////////////////////////////////////////////////////////////
2959 ///-----------------------------------------------------------------------------
2960 ////////////////////////////////////////////////////////////////////////////////
2961 /// @brief \b Function \b Name: HAL_AUDIO_WriteInitTable() @@Cathy
2962 /// @brief \b Function \b Description: This function is used to write initial register table(8-bit mode)
2963 /// @param <IN> \b NONE :
2964 /// @param <OUT> \b NONE :
2965 /// @param <RET> \b NONE :
2966 /// @param <GLOBAL> \b NONE :
2967 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteInitTable(void)2968 void HAL_AUDIO_WriteInitTable(void)
2969 {
2970 MS_U16 i = 0;
2971 MS_U16 j = 0;
2972 MS_U8 has_init = 0;
2973
2974 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
2975 {
2976 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
2977 {
2978 if(ResetDMIOTbl[j].u16Mask == 1)
2979 {
2980 if(ResetDMIOTbl[j].u16Value!=0)
2981 MsOS_DelayTask((MS_U32)(ResetDMIOTbl[j].u16Value));
2982 }
2983 }
2984 else
2985 {
2986 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
2987 }
2988
2989 j++;
2990 }
2991
2992 // check 0x112CE0 bit 12 to make sure audio has initialized or not
2993 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CODEC_CFG0+1) & 0x10) == 0)
2994 has_init = 1;
2995
2996 if (HAL_AUDIO_CheckBootOnInitState() == FALSE)
2997 {
2998
2999 while( !((AudioInitTbl_0[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_0[i].u8Mask == 0)) )
3000 {
3001 if((AudioInitTbl_0[i].u32Addr == 0xFFFFFF))
3002 {
3003 if(AudioInitTbl_0[i].u8Mask == 1)
3004 {
3005 if(AudioInitTbl_0[i].u8Value!=0)
3006 MsOS_DelayTask((MS_U32)(AudioInitTbl_0[i].u8Value));
3007 }
3008 }
3009 else
3010 {
3011 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_0[i].u32Addr, AudioInitTbl_0[i].u8Mask, AudioInitTbl_0[i].u8Value);
3012 }
3013
3014 i++;
3015 }
3016
3017 i = 0;
3018 if (has_init != 1)
3019 {
3020 while( !((AudioInitTbl_1[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_1[i].u8Mask == 0)) )
3021 {
3022 if((AudioInitTbl_1[i].u32Addr == 0xFFFFFF))
3023 {
3024 if(AudioInitTbl_1[i].u8Mask == 1)
3025 {
3026 if(AudioInitTbl_1[i].u8Value!=0)
3027 MsOS_DelayTask((MS_U32)(AudioInitTbl_1[i].u8Value));
3028 }
3029 }
3030 else
3031 {
3032 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_1[i].u32Addr, AudioInitTbl_1[i].u8Mask, AudioInitTbl_1[i].u8Value);
3033 }
3034
3035 i++;
3036 }
3037 }
3038
3039 i = 0;
3040 while( !((AudioInitTbl_2[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_2[i].u8Mask == 0)) )
3041 {
3042 if((AudioInitTbl_2[i].u32Addr == 0xFFFFFF))
3043 {
3044 if(AudioInitTbl_2[i].u8Mask == 1)
3045 {
3046 if(AudioInitTbl_2[i].u8Value!=0)
3047 MsOS_DelayTask((MS_U32)(AudioInitTbl_2[i].u8Value));
3048 }
3049 }
3050 else
3051 {
3052 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_2[i].u32Addr, AudioInitTbl_2[i].u8Mask, AudioInitTbl_2[i].u8Value);
3053 }
3054
3055 i++;
3056 }
3057
3058 i = 0;
3059 if (has_init != 1)
3060 {
3061 while( !((AudioInitTbl_3[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_3[i].u8Mask == 0)) )
3062 {
3063 if((AudioInitTbl_3[i].u32Addr == 0xFFFFFF))
3064 {
3065 if(AudioInitTbl_3[i].u8Mask == 1)
3066 {
3067 if(AudioInitTbl_3[i].u8Value!=0)
3068 MsOS_DelayTask((MS_U32)(AudioInitTbl_3[i].u8Value));
3069 }
3070 }
3071 else
3072 {
3073 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_3[i].u32Addr, AudioInitTbl_3[i].u8Mask, AudioInitTbl_3[i].u8Value);
3074 }
3075
3076 i++;
3077 }
3078 }
3079
3080 i = 0;
3081 while( !((AudioInitTbl_4[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_4[i].u8Mask == 0)) )
3082 {
3083 if((AudioInitTbl_4[i].u32Addr == 0xFFFFFF))
3084 {
3085 if(AudioInitTbl_4[i].u8Mask == 1)
3086 {
3087 if(AudioInitTbl_4[i].u8Value!=0)
3088 MsOS_DelayTask((MS_U32)(AudioInitTbl_4[i].u8Value));
3089 }
3090 }
3091 else
3092 {
3093 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_4[i].u32Addr, AudioInitTbl_4[i].u8Mask, AudioInitTbl_4[i].u8Value);
3094 }
3095
3096 i++;
3097 }
3098 }
3099
3100 i = 0;
3101 while( !((AudioInitTbl_5[i].u32Addr == 0xFFFFFF) && (AudioInitTbl_5[i].u8Mask == 0)) )
3102 {
3103 if((AudioInitTbl_5[i].u32Addr == 0xFFFFFF))
3104 {
3105 if(AudioInitTbl_5[i].u8Mask == 1)
3106 {
3107 if(AudioInitTbl_5[i].u8Value!=0)
3108 MsOS_DelayTask((MS_U32)(AudioInitTbl_5[i].u8Value));
3109 }
3110 }
3111 else
3112 {
3113 HAL_AUDIO_AbsWriteMaskByte(AudioInitTbl_5[i].u32Addr, AudioInitTbl_5[i].u8Mask, AudioInitTbl_5[i].u8Value);
3114 }
3115
3116 i++;
3117 }
3118
3119 // Set I2S RX synthesizer reference clock for different IC revision of U01, U02, U03
3120 if( SYS_GetChipRev() == 0x2) // IC = U03
3121 {
3122 HAL_AUDIO_WriteMaskByte(0x2CAF, 0xE0, 0x80); // 0x112CAE[15:13] = 0x4
3123 }
3124 else if(SYS_GetChipRev() <= 0x1) // IC = U01, U02
3125 {
3126 HAL_AUDIO_WriteMaskByte(0x2CAF, 0xE0, 0x20); // 0x112CAE[15:13] = 0x1
3127 }
3128
3129 }
3130
3131 ////////////////////////////////////////////////////////////////////////////////
3132 /// @brief \b Function \b Name: HAL_AUDIO_WritePreInitTable()
3133 /// @brief \b Function \b Description: This function is used to set power on DAC sequence before setting init table.
3134 /// @param <IN> \b NONE :
3135 /// @param <OUT> \b NONE :
3136 /// @param <RET> \b NONE :
3137 /// @param <GLOBAL> \b NONE :
3138 ////////////////////////////////////////////////////////////////////////////////
3139 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_WritePreInitTable(void)3140 void HAL_AUDIO_WritePreInitTable(void)
3141 {
3142 MS_U16 i = 0;
3143
3144 if (HAL_AUDIO_CheckBootOnInitState() == TRUE)
3145 {
3146 return;
3147 }
3148
3149 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CODEC_CFG0+1) & 0x10) == 0) {
3150 printf("Audio has initialized, don't need to do Pre init again\n");
3151 return;
3152 }
3153
3154 while( !((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF) && (AudioPreInitTbl_Clock[i].u8Mask == 0)) )
3155 {
3156 if((AudioPreInitTbl_Clock[i].u32Addr == 0xFFFFFF))
3157 {
3158 if(AudioPreInitTbl_Clock[i].u8Mask == 1)
3159 {
3160 if(AudioPreInitTbl_Clock[i].u8Value!=0)
3161 MsOS_DelayTask((MS_U32)(AudioPreInitTbl_Clock[i].u8Value));
3162 }
3163 }
3164 else
3165 {
3166 HAL_AUDIO_AbsWriteMaskByte(AudioPreInitTbl_Clock[i].u32Addr, AudioPreInitTbl_Clock[i].u8Mask, AudioPreInitTbl_Clock[i].u8Value);
3167 }
3168 i++;
3169 }
3170 }
3171
3172 ////////////////////////////////////////////////////////////////////////////////
3173 /// @brief \b Function \b Name: HAL_AUDIO_WriteStopDecTable()
3174 /// @brief \b Function \b Description: This function is used to set stop command to R2/DSP.
3175 /// @param <IN> \b NONE :
3176 /// @param <OUT> \b NONE :
3177 /// @param <RET> \b NONE :
3178 /// @param <GLOBAL> \b NONE :
3179 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_WriteStopDecTable(void)3180 void HAL_AUDIO_WriteStopDecTable(void)
3181 {
3182 MS_U16 i = 0;
3183
3184 while( !((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF) && (Audio_stopDecTbl[i].u8Mask == 0)) )
3185 {
3186 if((Audio_stopDecTbl[i].u32Addr == 0xFFFFFF))
3187 {
3188 if(Audio_stopDecTbl[i].u8Mask == 1)
3189 {
3190 if(Audio_stopDecTbl[i].u8Value!=0)
3191 MsOS_DelayTask((MS_U32)(Audio_stopDecTbl[i].u8Value));
3192 }
3193 }
3194 else
3195 {
3196 HAL_AUDIO_AbsWriteMaskByte(Audio_stopDecTbl[i].u32Addr, Audio_stopDecTbl[i].u8Mask, Audio_stopDecTbl[i].u8Value);
3197 }
3198 i++;
3199 }
3200 }
3201
3202 ////////////////////////////////////////////////////////////////////////////////
3203 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
3204 /// @brief \b Function \b Description: This function is used to enable earphone low power stage.
3205 /// @param <IN> \b NONE :
3206 /// @param <OUT> \b NONE :
3207 /// @param <RET> \b NONE :
3208 /// @param <GLOBAL> \b NONE :
3209 ////////////////////////////////////////////////////////////////////////////////
3210 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_LowPower_Stage(void)3211 void HAL_AUDIO_EnaEarphone_LowPower_Stage(void)
3212 {
3213
3214 HAL_AUDIO_WriteMaskByte(0x2CEC, 0xFF, 0x00); //wriu -w 0x112cec 0x1800 //EN_STG2_AB_EAR=1,EN_STG2_LP_EAR=1,PD_LDO=0,EN_QS_LDO=0
3215 HAL_AUDIO_WriteMaskByte(0x2CED, 0xFF, 0x18);
3216 HAL_AUDIO_WriteMaskByte(0x2CEE, 0xFF, 0x03); //wriu -w 0x112cee 0x0303 //MSP=0,EN_EAR=1,EN_MUTE_EAR=0, SEL_DEPOP_EAR[1:0]=11
3217 HAL_AUDIO_WriteMaskByte(0x2CEF, 0xFF, 0x03);
3218 return;
3219 }
3220
3221 ////////////////////////////////////////////////////////////////////////////////
3222 /// @brief \b Function \b Name: HAL_AUDIO_WritePostInitTable()
3223 /// @brief \b Function \b Description: This function is used to enable earphone high driving stage.
3224 /// @param <IN> \b NONE :
3225 /// @param <OUT> \b NONE :
3226 /// @param <RET> \b NONE :
3227 /// @param <GLOBAL> \b NONE :
3228 ////////////////////////////////////////////////////////////////////////////////
3229 //Refine power on sequence for earphone & DAC pop noise issue
HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)3230 void HAL_AUDIO_EnaEarphone_HighDriving_Stage(void)
3231 {
3232 return;
3233 }
3234
3235 ////////////////////////////////////////////////////////////////////////////////
3236 /// @brief \b Function \b Name: HAL_AUDIO_SetPowerOn() @@Need_Modify
3237 /// @brief \b Function \b Description: This routine is used to execute DSP power on/down setting.
3238 /// @param <IN> \b bPower_on : TRUE --power on
3239 /// FALSE--power off
3240 /// @param <OUT> \b NONE :
3241 /// @param <RET> \b NONE :
3242 /// @param <GLOBAL> \b NONE :
3243 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)3244 void HAL_AUDIO_SetPowerOn(MS_BOOL bPower_on)
3245 {
3246 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "HAL_AUDIO_SetPowerOn(%x)\r\n", bPower_on);
3247 if(bPower_on)
3248 {
3249 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x00); // DSP power up command, DO NOT touch bit3
3250 HAL_AUDIO_WriteMaskByte(0x2B42, 0xFF, 0x00); // Disable BB by-pass
3251 }
3252 else
3253 {
3254 #ifdef AUDIO_UTOPIA2K
3255 g_AudioVars2->g_Audio_PreInitFlag = FALSE;
3256 HAL_AUDIO_SET_INIT_FLAG(FALSE);
3257 #else
3258 HAL_AUDIO_DeInitialVars();
3259 #endif
3260 HAL_AUDIO_WriteMaskByte(REG_D2M_MAILBOX_SE_POWERCTRL, 0x02, 0x02); // DSP power down command
3261 AUDIO_DELAY1MS(100);
3262
3263 // Disable MIU Request for DEC-DSP
3264 HAL_MAD_Dis_MIUREQ();
3265
3266 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00); // SPDIF power down
3267 }
3268 }
3269
3270 ////////////////////////////////////////////////////////////////////////////////
3271 /// @brief \b Function \b Name: HAL_AUDIO_ADCInit() @@Cathy
3272 /// @brief \b Function \b Description: This routine is ADC relational register Init.
3273 /// @param <IN> \b NONE :
3274 /// @param <OUT> \b NONE :
3275 /// @param <RET> \b NONE :
3276 /// @param <GLOBAL> \b NONE :
3277 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ADCInit(void)3278 void HAL_AUDIO_ADCInit(void)
3279 {
3280 HAL_AUDIO_WriteMaskByte(0x2CDA, 0x03, 0x00); // power on ADC0 & ADC1
3281 HAL_AUDIO_WriteMaskByte(0x2CEE, 0x03, 0x03); //enable ADC dither
3282 HAL_AUDIO_WriteMaskByte(0x2CE3, 0x03, 0x00); // power on ADC PGA
3283 HAL_AUDIO_WriteMaskByte(0x2CE5, 0xFC, 0x00); //ADC0 & ADC1 PGAain=0dB
3284 }
3285
3286 ////////////////////////////////////////////////////////////////////////////////
3287 /// @brief \b Function \b Name: HAL_AUDIO_SwResetMAD() @@Cathy
3288 /// @brief \b Function \b Description: This function is used to software reset MAD
3289 /// @param <IN> \b NONE :
3290 /// @param <OUT> \b NONE :
3291 /// @param <RET> \b NONE :
3292 /// @param <GLOBAL> \b NONE :
3293 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SwResetMAD(void)3294 void HAL_AUDIO_SwResetMAD(void)
3295 {
3296 MS_U16 j = 0;
3297
3298 while( !((ResetDMIOTbl[j].u32Addr == 0xFFFFFF) && (ResetDMIOTbl[j].u16Mask == 0)) )
3299 {
3300 if((ResetDMIOTbl[j].u32Addr == 0xFFFFFF))
3301 {
3302 if(ResetDMIOTbl[j].u16Mask == 1)
3303 {
3304 if(ResetDMIOTbl[j].u16Value!=0)
3305 AUDIO_DELAY1MS((MS_U32)(ResetDMIOTbl[j].u16Value));
3306 }
3307 }
3308 else
3309 {
3310 HAL_AUDIO_AbsWriteMaskReg(ResetDMIOTbl[j].u32Addr, ResetDMIOTbl[j].u16Mask, ResetDMIOTbl[j].u16Value);
3311 }
3312
3313 j++;
3314 }
3315
3316 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CODEC_CFG0+1) & 0x10) == 0) {
3317 printf("Audio has initialized, don't need to do SwReset again\n");
3318 return;
3319 }
3320
3321 /* Audio software engine reset */
3322 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
3323 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
3324 AUDIO_DELAY1MS(1);
3325 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0F);
3326 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
3327 AUDIO_DELAY1MS(1);
3328 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x0D);
3329 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x7F);
3330 AUDIO_DELAY1MS(1);
3331 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SOFT_RESET, 0xFF, 0x00);
3332 HAL_AUDIO_WriteMaskByte((REG_AUDIO_SOFT_RESET+1), 0xFF, 0x00);
3333 AUDIO_DELAY1MS(1);
3334 }
3335
3336 ////////////////////////////////////////////////////////////////////////////////
3337 /// @brief \b Function \b Name: HAL_AUDIO_ResetDSP() @@Cathy
3338 /// @brief \b Function \b Description: This function is used to reset DSP.
3339 /// @param <IN> \b NONE :
3340 /// @param <OUT> \b NONE :
3341 /// @param <RET> \b NONE :
3342 /// @param <GLOBAL> \b NONE :
3343 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ResetDSP(void)3344 void HAL_AUDIO_ResetDSP(void)
3345 {
3346 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x02); // Reset DSP
3347 AUDIO_DELAY1MS(2);
3348 HAL_AUDIO_DecWriteByte(REG_DEC_IDMA_CTRL0, 0x03);
3349 }
3350
3351 ////////////////////////////////////////////////////////////////////////////////
3352 /// @brief \b Function \b Name: HAL_AUDIO_DecDspISR() @@Need_Modify
3353 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
3354 /// @param <IN> \b NONE :
3355 /// @param <OUT> \b NONE :
3356 /// @param <RET> \b NONE :
3357 /// @param <GLOBAL> \b NONE :
3358 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecDspISR(void)3359 void HAL_AUDIO_DecDspISR(void) //Cathy need modify
3360 {
3361 MS_U8 dec_ISR_cmdType;
3362
3363 dec_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_DEC_ISRCMD);
3364
3365 HALAUDIO_CHECK_SHM_INIT;
3366
3367 if(dec_ISR_cmdType == 0x3)
3368 {
3369 g_AudioVars2->g_bDecPlayFileFlag = TRUE;
3370 }
3371 else if(dec_ISR_cmdType == 0x13) // MPEG encode ISR
3372 {
3373 HAL_AUDIO_SetEncodeDoneFlag(1); // for PVR encode done, kochien modified
3374 EncBuf_Count++; // remaining data in buffer
3375 EncFrameIdx += 16; //default 16 frames / interrupt
3376 MPEG_EN_BUF[EncBuf_W_idx].u32Addr = ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINEADDR))*16;
3377 MPEG_EN_BUF[EncBuf_W_idx].u32Size= ((MS_U32)HAL_AUDIO_ReadReg(REG_DEC_D2M_MAIL_BOX_ENC_LINESIZE))*16;
3378 MPEG_EN_BUF[EncBuf_W_idx].u64Idx= (MS_U64)EncFrameIdx; //(MS_U64)(((EncFrameIdx-1)*1152*90)/48);
3379
3380 if(EncBuf_W_idx == 5)// (ENC_BUF_SIZE-1)) // circular buffer // manually circular...
3381 EncBuf_W_idx = 0;
3382 else
3383 EncBuf_W_idx++;
3384 }
3385 else if (dec_ISR_cmdType == 0x07) // 2nd Decoder ISR in MM
3386 {
3387 g_AudioVars2->g_bSePlayFileFlag = TRUE;
3388 }
3389 }
3390
3391 ////////////////////////////////////////////////////////////////////////////////
3392 /// @brief \b Function \b Name: HAL_AUDIO_SeDspISR() @@Need_Modify
3393 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
3394 /// @param <IN> \b NONE :
3395 /// @param <OUT> \b NONE :
3396 /// @param <RET> \b NONE :
3397 /// @param <GLOBAL> \b NONE :
3398 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeDspISR(void)3399 void HAL_AUDIO_SeDspISR(void)
3400 {
3401 MS_U8 se_ISR_cmdType;
3402
3403 se_ISR_cmdType = HAL_AUDIO_ReadByte(REG_D2M_MAILBOX_SE_ISRCMD);
3404
3405 /* add for PIP ASND Decode */
3406 if ( se_ISR_cmdType == 0x03 )
3407 {
3408 if (g_AudioVars2 != NULL)
3409 {
3410 g_AudioVars2->g_bSePlayFileFlag = TRUE;
3411 }
3412 }
3413 }
3414
3415 ////////////////////////////////////////////////////////////////////////////////
3416 /// @brief \b Function \b Name: HAL_AUDIO_SetPlayFileFlag() @Cathy
3417 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
3418 /// @param <IN> \b NONE :
3419 /// @param <OUT> \b NONE :
3420 /// @param <RET> \b NONE :
3421 /// @param <GLOBAL> \b NONE :
3422 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType,MS_BOOL bSet)3423 void HAL_AUDIO_SetPlayFileFlag(MS_BOOL bDspType, MS_BOOL bSet)
3424 {
3425 HALAUDIO_CHECK_SHM_INIT;
3426
3427 if(bDspType == DSP_DEC)
3428 {
3429 g_AudioVars2->g_bDecPlayFileFlag = bSet;
3430 }
3431 else
3432 {
3433 g_AudioVars2->g_bSePlayFileFlag = bSet;
3434 }
3435 }
3436
3437 ////////////////////////////////////////////////////////////////////////////////
3438 /// @brief \b Function \b Name: HAL_AUDIO_GetPlayFileFlag() @@Cathy
3439 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
3440 /// @param <IN> \b NONE :
3441 /// @param <OUT> \b NONE :
3442 /// @param <RET> \b NONE :
3443 /// @param <GLOBAL> \b NONE :
3444 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)3445 MS_BOOL HAL_AUDIO_GetPlayFileFlag(MS_BOOL bDspType)
3446 {
3447 MS_U32 es_rdPtr, es_wrPtr;
3448 MS_S32 es_level, es_bufSz, es_freeSpace;
3449 MS_U32 es_reqSize;
3450 MS_U8 r2_dec_id;
3451
3452 if (bDspType ==DSP_DEC)
3453 r2_dec_id = ADEC1;
3454 else if(bDspType ==DSP_SE)
3455 r2_dec_id = ADEC2;
3456 else
3457 r2_dec_id = ADEC1; //default case
3458
3459 es_rdPtr = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_ES_RD_PTR, r2_dec_id );
3460 es_wrPtr = HAL_DEC_R2_Get_SHM_PARAM( R2_SHM_PARAM_ES_WR_PTR, r2_dec_id, 0 );
3461 es_reqSize = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, r2_dec_id);
3462
3463 es_bufSz = ES1_DRAM_SIZE;
3464 es_level = es_wrPtr - es_rdPtr;
3465
3466 if (es_level < 0)
3467 es_level += es_bufSz;
3468
3469 es_freeSpace = es_bufSz - es_level;
3470
3471 if ( es_freeSpace > es_reqSize )
3472 return TRUE;
3473 else
3474 return FALSE;
3475 }
3476
3477 ////////////////////////////////////////////////////////////////////////////////
3478 /// @brief \b Function \b Name: HAL_AUDIO_SetEncodeDoneFlag() @@Cathy
3479 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
3480 /// @param <IN> \b NONE :
3481 /// @param <OUT> \b NONE :
3482 /// @param <RET> \b NONE :
3483 /// @param <GLOBAL> \b NONE :
3484 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)3485 void HAL_AUDIO_SetEncodeDoneFlag(MS_BOOL bSet)
3486 {
3487 if (bSet)
3488 g_bEncodeDoneFlag= 1;
3489 else
3490 g_bEncodeDoneFlag = 0;
3491 }
3492
3493 ////////////////////////////////////////////////////////////////////////////////
3494 /// @brief \b Function \b Name: HAL_AUDIO_GetEncodeDoneFlag() @@Cathy
3495 /// @brief \b Function \b Description: This function is used to get the Encoder flag status
3496 /// @param <IN> \b NONE :
3497 /// @param <OUT> \b NONE :
3498 /// @param <RET> \b NONE :
3499 /// @param <GLOBAL> \b NONE :
3500 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetEncodeDoneFlag(void)3501 MS_BOOL HAL_AUDIO_GetEncodeDoneFlag(void)
3502 {
3503 return g_bEncodeDoneFlag;
3504 }
3505
3506 ////////////////////////////////////////////////////////////////////////////////
3507 /// @brief \b Function \b Name: HAL_AUDIO_CheckBootOnInitState()
3508 /// @brief \b Function \b Description: This routine is used to check whether mboot load init script
3509 /// @param void
3510 /// @return MS_U16 \b : Mail Box value
3511 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckBootOnInitState(void)3512 MS_BOOL HAL_AUDIO_CheckBootOnInitState(void)
3513 {
3514 if ((HAL_AUDIO_ReadByte(REG_AUDIO_AUDIO_INIT_CHECK) & 0x1) == 0)
3515 {
3516 return FALSE;
3517 }
3518 else
3519 {
3520 return TRUE;
3521 }
3522 }
3523
3524 /////////////////////////////////////////////////////////////////////////////////
3525 /// ///
3526 /// AUDIO I/O Config Relational Hal Function ///
3527 /// ///
3528 ////////////////////////////////////////////////////////////////////////////////
3529
3530 ////////////////////////////////////////////////////////////////////////////////
3531 /// @brief \b Function \b Name: HAL_AUDIO_GetPathGroup()
3532 /// @brief \b Function \b Description: This routine is used to get Audio path group type .
3533 /// @param output \b : Audio output path-group type
3534 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetPathGroup(void)3535 AUDIO_PATH_GROUP_TYPE HAL_AUDIO_GetPathGroup(void)
3536 {
3537 // AUDIO_PATH_GROUP_1 : U3, Janus
3538 // AUDIO_PATH_GROUP_2 : T3, U4, T8, T9, T12, T13, J2
3539 return(AUDIO_PATH_GROUP_2);
3540 }
3541
3542 ////////////////////////////////////////////////////////////////////////////////
3543 /// @brief \b Function \b Name: HAL_AUDIO_SetNormalPath() @@ No used in T3 @@VVV
3544 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input and Output.
3545 /// @param <IN> \b u8Path : Audio DSP channel
3546 /// @param <IN> \b input : Audio input type
3547 /// @param <IN> \b output : Audio output type
3548 /// @param <OUT> \b NONE :
3549 /// @param <RET> \b NONE :
3550 /// @param <GLOBAL> \b NONE :
3551 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path,AUDIO_INPUT_TYPE input,AUDIO_OUTPUT_TYPE output)3552 void HAL_AUDIO_SetNormalPath(AUDIO_PATH_TYPE u8Path, AUDIO_INPUT_TYPE input, AUDIO_OUTPUT_TYPE output)
3553 {
3554 u8Path=u8Path;
3555 input=input;
3556 output=output;
3557 }
3558
3559 ////////////////////////////////////////////////////////////////////////////////
3560 /// @brief \b Function \b Name: HAL_AUDIO_SetInputPath() @@VVV
3561 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Input .
3562 /// @param <IN> \b input : Audio input type
3563 /// @param <IN> \b u8Path : Audio DSP channel
3564 /// @param <OUT> \b NONE :
3565 /// @param <RET> \b NONE :
3566 /// @param <GLOBAL> \b NONE :
3567 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input,AUDIO_PATH_TYPE u8Path)3568 void HAL_AUDIO_SetInputPath(AUDIO_INPUT_TYPE input , AUDIO_PATH_TYPE u8Path)
3569 {
3570 MS_U32 u32path_reg;
3571 MS_U8 u8input_src, u8input_idx, u8temp, path;
3572 AUDIO_INPUT_TYPE input1; // define this in order to do more check for ATV input source.
3573 input1 = input;
3574
3575 HALAUDIO_CHECK_SHM_INIT;
3576
3577 if((input == AUDIO_NULL_INPUT) || (u8Path ==AUDIO_PATH_NULL))
3578 {
3579 return;
3580 }
3581
3582 u8input_src = LONIBBLE(input);
3583 u8input_idx = HINIBBLE(input);
3584
3585 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
3586 {
3587 input1 = AUDIO_DSP4_SIF_INPUT;
3588 u8input_src = LONIBBLE(input1);
3589 }
3590
3591 if( u8Path == AUDIO_PATH_MAIN )
3592 {
3593 if (u8input_src == AUDIO_ADC_INPUT || u8input_src == AUDIO_ADC2_INPUT)
3594 {
3595 HAL_SOUND_EnableDcRemove(TRUE);
3596 }
3597 else
3598 {
3599 HAL_SOUND_EnableDcRemove(FALSE);
3600 }
3601 }
3602
3603 path=(MS_U8)u8Path;
3604
3605 /* save main speaker audio input */
3606 if( u8Path == AUDIO_PATH_MAIN )
3607 {
3608 g_AudioVars2->eMainAudioSource = input1;
3609 }
3610 /* save sub channel audio input */
3611 else if( u8Path == AUDIO_PATH_6 )
3612 {
3613 g_AudioVars2->eSubAudioSource = input1;
3614 }
3615
3616 if( path >= (sizeof(u32PathArray)/sizeof(u32PathArray[0])))
3617 {
3618 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "DSP is not support more than CH8\n");
3619 return;
3620 }
3621
3622 u32path_reg = u32PathArray[path];
3623
3624 // Set input
3625 switch(u8input_src)
3626 {
3627 case AUDIO_DSP1_INPUT:
3628 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x80);
3629 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG, 0x07,u8input_idx); // Set main parser source
3630 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx); // Set AD parser source
3631 break;
3632
3633 case AUDIO_DSP2_INPUT:
3634 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x81);
3635 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER2_CFG, 0x07,u8input_idx);
3636 break;
3637
3638 case AUDIO_DSP3_INPUT:
3639 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x82);
3640 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG, 0x07,u8input_idx);
3641 break;
3642
3643 case AUDIO_DSP4_INPUT:
3644 /*
3645 * A patch here!
3646 * Just a temporary solution to hardcode channel 7 to 0x90 for HW DMA Reader2,
3647 */
3648 if (u8input_idx == 0x7)
3649 {
3650 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x83);
3651 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER4_CFG, 0x07,u8input_idx);
3652 } else {
3653 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x90);
3654 }
3655 break;
3656
3657 case AUDIO_ADC_INPUT:
3658 if(u8input_idx==0x0A)
3659 u8temp=0x40;
3660 else if(u8input_idx==0x0B)
3661 u8temp=0x50;
3662 else
3663 u8temp = (u8input_idx<<4);
3664 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x88);
3665 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, u8temp );
3666 break;
3667
3668 case AUDIO_ADC2_INPUT:
3669 if(u8input_idx==0x0A)
3670 u8temp=0x04;
3671 else if(u8input_idx==0x0B)
3672 u8temp=0x05;
3673 else
3674 u8temp = u8input_idx;
3675 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x89);
3676 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp );
3677 break;
3678
3679 case AUDIO_SPDIF_INPUT:
3680 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x86);
3681 break;
3682
3683 case AUDIO_I2S_INPUT:
3684 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x85);
3685 break;
3686
3687 case AUDIO_HDMI_INPUT:
3688 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x84);
3689 break;
3690
3691 case AUDIO_DMA_INPUT:
3692 HAL_AUDIO_WriteMaskByte(u32path_reg, 0x9F, 0x8F);
3693 break;
3694
3695 default:
3696 break;
3697 }
3698
3699 return;
3700 }
3701
3702 ////////////////////////////////////////////////////////////////////////////////
3703 /// @brief \b Function \b Name: HAL_AUDIO_SetOutputPath() @@Need_Modify
3704 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
3705 /// @param <IN> \b u8Path : Audio DSP channel
3706 /// @param <IN> \b output : Audio output type
3707 /// @param <OUT> \b NONE :
3708 /// @param <RET> \b NONE :
3709 /// @param <GLOBAL> \b NONE :
3710 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)3711 void HAL_AUDIO_SetOutputPath(AUDIO_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
3712 {
3713 u8Path=u8Path;
3714 u8Output=u8Output;
3715 }
3716
3717 ////////////////////////////////////////////////////////////////////////////////
3718 /// @brief \b Function \b Name: HAL_AUDIO_SetInternalPath() @@VVV
3719 /// @brief \b Function \b Description: This routine is used to set the topalogy for Audio Output.
3720 /// @param <IN> \b u8Path : Audio internal path
3721 /// @param <IN> \b output : Audio output type
3722 /// @param <OUT> \b NONE :
3723 /// @param <RET> \b NONE :
3724 /// @param <GLOBAL> \b NONE :
3725 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path,AUDIO_OUTPUT_TYPE u8Output)3726 void HAL_AUDIO_SetInternalPath(AUDIO_INTERNAL_PATH_TYPE u8Path, AUDIO_OUTPUT_TYPE u8Output)
3727 {
3728 MS_U8 path;
3729 // OUT0, OUT1, OUT2 , OUT3 , S/PDIF, I2S, HP , Dummy
3730 MS_U8 BalanceBitMap[8]={ 0, 1, 2, 3, 8, 4, 1, 7 };
3731
3732 if(u8Path >= INTERNAL_MAX_NUM)
3733 return;
3734
3735 path = (MS_U8)u8Path;
3736
3737 if(u8Path==INTERNAL_PCM_SE) // Only speaker use this path
3738 {
3739 g_BalanceMask=g_BalanceMask|(0x01<<BalanceBitMap[(int)u8Output]); // Enable balance mask
3740 }
3741
3742 if((HAL_AUDIO_ReadByte(M2S_MBOX_BALANCE_EN+1)&0x80)!=0)
3743 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
3744 else
3745 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000); // Balance disable
3746
3747 // Set output
3748 switch(u8Output)
3749 {
3750 case AUDIO_AUOUT0_OUTPUT:
3751 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0x0F, path);
3752 break;
3753
3754 case AUDIO_AUOUT1_OUTPUT:
3755 case AUDIO_HP_OUTPUT:
3756 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1, 0xF0, (path<<4));
3757 break;
3758
3759 case AUDIO_AUOUT2_OUTPUT:
3760 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0x0F, path);
3761 break;
3762
3763 case AUDIO_AUOUT3_OUTPUT:
3764 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL1+1, 0xF0, (path<<4));
3765 break;
3766
3767 case AUDIO_I2S_OUTPUT:
3768 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0x0F, path);
3769 break;
3770
3771 case AUDIO_SPDIF_OUTPUT:
3772 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL3+1, 0x0F, path); // Fix PCM in
3773 break;
3774
3775 case AUDIO_I2S2_OUTPUT:
3776 HAL_AUDIO_WriteMaskByte(M2S_MBOX_INPUT_MUX_SEL2, 0xF0, (path<<4));
3777 break;
3778
3779 default:
3780 break;
3781 }
3782
3783 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_SPK_OutChannel, g_AudioVars2->AudioPathInfo.SpeakerOut, DSP_MEM_TYPE_PM); // INFO DSP SPK Output channel
3784 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_HP_OutChannel, g_AudioVars2->AudioPathInfo.HpOut, DSP_MEM_TYPE_PM); // INFO DSP HP Output channel
3785 }
3786
3787
3788 ////////////////////////////////////////////////////////////////////////////////
3789 /// @brief \b Function \b Name: HAL_AUDIO_FwTriggerDSP() @@Need_Modify
3790 /// @brief \b Function \b Description: This routine send a PIO11 interrupt to DSP with a command on 0x2D34.
3791 /// @param <IN> \b cmd : 0xF0-- for MHEG5 file protocol
3792 /// @param <OUT> \b NONE :
3793 /// @param <RET> \b NONE :
3794 /// @param <GLOBAL> \b NONE :
3795 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd)3796 void HAL_AUDIO_FwTriggerDSP(MS_U16 u16Cmd) //Cathy need modify
3797 {
3798 u16Cmd = u16Cmd;
3799 }
3800
3801 ////////////////////////////////////////////////////////////////////////////////
3802 /// @brief \b Function \b Name: HAL_AUDIO_DspBootOnDDR()
3803 /// @brief \b Function \b Description: Enable DSP load / reload code from DDR
3804 /// @param <IN> \b bEnable : 0 -- load code from FLASH
3805 /// 1 -- load code from DDR
3806 /// @param <OUT> \b NONE :
3807 /// @param <RET> \b NONE :
3808 /// @param <GLOBAL> \b NONE :
3809 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)3810 void HAL_AUDIO_DspBootOnDDR(MS_BOOL bEnable)
3811 {
3812 g_bAudio_loadcode_from_dram = bEnable;
3813 }
3814
3815 ////////////////////////////////////////////////////////////////////////////////
3816 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3817 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3818 /// @param <IN> \b NONE :
3819 /// @param <OUT> \b NONE :
3820 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3821 /// @param <GLOBAL> \b NONE :
3822 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetIsDtvFlag(void)3823 MS_BOOL HAL_AUDIO_GetIsDtvFlag(void)
3824 {
3825 return g_bIsDTV;
3826 }
3827
3828 ////////////////////////////////////////////////////////////////////////////////
3829 /// @brief \b Function \b Name: HAL_AUDIO_GetIsDtvFlag() @@Cathy
3830 /// @brief \b Function \b Description: Report the decoder type is ATV or DTV
3831 /// @param <IN> \b NONE :
3832 /// @param <OUT> \b NONE :
3833 /// @param <RET> \b g_bIsDTV: 0 -> ATV , 1 -> DTV
3834 /// @param <GLOBAL> \b NONE :
3835 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)3836 void HAL_AUDIO_SetIsDtvFlag(MS_BOOL bIsDTV)
3837 {
3838 g_bIsDTV=bIsDTV;
3839 }
3840
3841 ////////////////////////////////////////////////////////////////////////////////
3842 /// @brief \b Function \b Name: HAL_AUDIO_Dec_Status() @@Cathy
3843 /// @brief \b Function \b Description: This routine is used to read the Decoder status.
3844 /// @param <IN> \b NONE :
3845 /// @param <OUT> \b NONE :
3846 /// @param <RET> \b MS_U8 : Decoder Status
3847 /// @param <GLOBAL> \b NONE :
3848 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Dec_Status(void)3849 MS_U8 HAL_AUDIO_Dec_Status(void)
3850 {
3851 return(HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD));
3852 }
3853
3854 ////////////////////////////////////////////////////////////////////////////////
3855 /// @brief \b Function \b Name: HAL_AUDIO_Enc_Status() @@Kochien.Kuo
3856 /// @brief \b Function \b Description: This routine is used to read the Encoder status.
3857 /// @param <IN> \b NONE :
3858 /// @param <OUT> \b NONE :
3859 /// @param <RET> \b MS_U8 : Encoder Status
3860 /// @param <GLOBAL> \b NONE :
3861 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Enc_Status(void)3862 MS_U8 HAL_AUDIO_Enc_Status(void)
3863 {
3864 return(HAL_AUDIO_ReadByte(REG_DEC_ENCODE_CMD));
3865 }
3866
3867 ////////////////////////////////////////////////////////////////////////////////
3868 /// @brief \b Function \b Name: HAL_AUDIO_SE_Status() @@Cathy
3869 /// @brief \b Function \b Description: This routine is used to read the SE status.
3870 /// @param <IN> \b NONE :
3871 /// @param <OUT> \b NONE :
3872 /// @param <RET> \b MS_U8 : Decoder Status
3873 /// @param <GLOBAL> \b NONE :
3874 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Se_Status(void)3875 MS_U8 HAL_AUDIO_Se_Status(void)
3876 {
3877 return(HAL_AUR2_ReadByte(REG_R2_DECODE2_CMD));
3878 }
3879
3880 ////////////////////////////////////////////////////////////////////////////////
3881 /// @brief \b Function \b Name: HAL_AUDIO_Set_Fading() @@Need_Modify
3882 /// @brief \b Function \b Description: This routine is used to set the Fading response time
3883 /// @param <IN> \b u32VolFading : Fading response time parameter
3884 /// @param <OUT> \b NONE :
3885 /// @param <RET> \b NONE :
3886 /// @param <GLOBAL> \b NONE :
3887 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)3888 void HAL_AUDIO_Set_Fading(MS_U32 u32VolFading)
3889 {
3890 HAL_MAD2_Write_DSP_sram(0x114C, u32VolFading, DSP_MEM_TYPE_PM); //need touch
3891 }
3892
3893
3894 ////////////////////////////////////////////////////////////////////////////////
3895 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetUploadRate() @@Need_Modify
3896 /// @brief \b Function \b Description: According Blue tooth upload path, for different sampling rate setting the Synthesizer.
3897 /// @param <IN> \b bEnable : 0 -- Disable Blue Tooth upload
3898 /// 1 -- Enable Blue Tooth upload
3899 /// @param <IN> \b u8Samprate: Sampling Rate
3900 /// 0--no change
3901 /// 1--48KHz
3902 /// 2--44KHz
3903 /// 3--32KHz
3904 /// @param <OUT> \b NONE :
3905 /// @param <RET> \b NONE :
3906 /// @param <GLOBAL> \b NONE :
3907 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)3908 void HAL_AUDIO_BT_SetUploadRate(MS_BOOL bEnable,MS_U8 u8Samprate)
3909 {
3910 u8Samprate &= 0x0003;
3911
3912 if(bEnable)
3913 {
3914 HAL_AUDIO_DecWriteByte(0x2C5A, 0x55);
3915 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0x10);
3916 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,u8Samprate);
3917 }
3918 else
3919 {
3920 HAL_AUDIO_DecWriteByte(0x2C5A, 0);
3921 HAL_AUDIO_DecWriteMaskByte(0x2D6C,0x10,0);
3922 HAL_AUDIO_DecWriteMaskByte(0x2D34,0x03,0);
3923 }
3924 }
3925
3926
3927 ////////////////////////////////////////////////////////////////////////////////
3928 /// @brief \b Function \b Name: HAL_AUDIO_BT_SetBufferCounter() @@Need_Modify
3929 /// @brief \b Function \b Description: Set the DDR buffer according the sampling rate and the frame time
3930 /// @param <IN> \b u32Counter : if the sampling rate is 48KHz, the frame time is 40ms
3931 /// ==> the frame buffer size is 48000*0x04*2 (L/R) *2(Bytes/sample) = 0x1E00
3932 /// the counter is 0x1E00/8 = 960 (For 1*Burst DMA)
3933 /// @param <OUT> \b NONE :
3934 /// @param <RET> \b NONE :
3935 /// @param <GLOBAL> \b NONE :
3936 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)3937 void HAL_AUDIO_BT_SetBufferCounter(MS_U32 u32Counter)
3938 {
3939 u32Counter &= 0x00FFFFFF;
3940 HAL_MAD2_Write_DSP_sram(DSP2PmAddr_btFrameSize, u32Counter, DSP_MEM_TYPE_PM);
3941 }
3942
3943 ////////////////////////////////////////////////////////////////////////////////
3944 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_Enable() @@Need_Modify
3945 /// @brief \b Function \b Description: Enable/ Disable the path of USB PCM
3946 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
3947 /// @param <OUT> \b NONE :
3948 /// @param <RET> \b NONE :
3949 /// @param <GLOBAL> \b NONE :
3950 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)3951 void HAL_AUDIO_USBPCM_Enable(MS_BOOL bEnable)
3952 {
3953 //this funcion is removed from DSP
3954 UNUSED(bEnable);
3955 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3956 }
3957
3958
3959 ////////////////////////////////////////////////////////////////////////////////
3960 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetFlag() @@Need_Modify
3961 /// @brief \b Function \b Description: Get interrupt flag for USBPCM function
3962 /// \b (Encoder path)
3963 /// @param <IN> \b NONE :
3964 /// @param <OUT> \b NONE :
3965 /// @param <RET> \b BOOL : interrupt flag
3966 /// @param <GLOBAL> \b NONE :
3967 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetFlag()3968 MS_BOOL HAL_AUDIO_USBPCM_GetFlag()
3969 {
3970 //this funcion is removed from DSP
3971 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3972 return 0;
3973 }
3974
3975 ////////////////////////////////////////////////////////////////////////////////
3976 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_SetFlag() @@Need_Modify
3977 /// @brief \b Function \b Description: clear interrupt flag for USBPCM function
3978 /// \b (Encoder path)
3979 /// @param <IN> \b bEnable : set false to clean interrupt flag
3980 /// @param <OUT> \b NONE :
3981 /// @param <RET> \b NONE :
3982 /// @param <GLOBAL> \b NONE :
3983 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)3984 void HAL_AUDIO_USBPCM_SetFlag(MS_BOOL bEnable)
3985 {
3986 //this funcion is removed from DSP
3987 UNUSED(bEnable);
3988 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
3989 }
3990
3991 ////////////////////////////////////////////////////////////////////////////////
3992 /// @brief \b Function \b Name: HAL_AUDIO_USBPCM_GetMemInfo() @@Need_Modify
3993 /// @brief \b Function \b Description: Get memory address and size for USBPCM function
3994 /// \b (Encoder path)
3995 /// @param <IN> \b NONE :
3996 /// @param <OUT> \b MS_U32 : address, size
3997 /// @param <RET> \b NONE :
3998 /// @param <GLOBAL> \b NONE :
3999 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO * uploadInfo)4000 void HAL_AUDIO_USBPCM_GetMemInfo(AUDIO_UPLOAD_INFO *uploadInfo)
4001 {
4002 //this funcion is removed from DSP
4003 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Error! unsupported funcion !!!\n", __FUNCTION__);
4004 }
4005
4006 ////////////////////////////////////////////////////////////////////////////////
4007 /// @brief \b Function \b Name: HAL_AUDIO_ I2S_SetMode() @@Need_Modify
4008 /// @brief \b Function \b Description: This routine is used to Set the I2S output mode.
4009 /// @param <IN> \b Mode : MCLK , WORD_WIDTH , SOURCE_CH , FORMAT
4010 /// @param <IN> \b Value : Please reference the register table 0x2C8C & 0x2C8D .
4011 /// @param <OUT> \b NONE :
4012 /// @param <RET> \b NONE :
4013 /// @param <GLOBAL> \b NONE :
4014 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode,MS_U8 u8Val)4015 void _HAL_AUDIO_I2S_SetMode(MS_U8 u8Mode, MS_U8 u8Val)
4016 {
4017 switch(u8Mode)
4018 {
4019 case AUDIO_I2S_MCLK: //0x2C8C[6:4]
4020 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x70,u8Val<<4);
4021 break;
4022
4023 case AUDIO_I2S_WORD_WIDTH: //0x163E12[11:8]
4024 // for backward compatible, set I2S_WORD_WIDTH value for Maserati here
4025 if (u8Val == I2S_WORD_WIDTH_16BIT)
4026 HAL_AUDIO_AbsWriteMaskByte(REG_I2S_TX_CLK_CTRL+1,0x0F,0x0);
4027 else if (u8Val == I2S_WORD_WIDTH_24BIT)
4028 HAL_AUDIO_AbsWriteMaskByte(REG_I2S_TX_CLK_CTRL+1,0x0F,0x3);
4029 else if (u8Val == I2S_WORD_WIDTH_32BIT)
4030 HAL_AUDIO_AbsWriteMaskByte(REG_I2S_TX_CLK_CTRL+1,0x0F,0x4);
4031 else
4032 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - I2S_WORD_WIDTH %d not exist\n",__FUNCTION__, u8Val);
4033 break;
4034
4035 case AUDIO_I2S_FORMAT: //0x2C8C[3]
4036 HAL_AUDIO_WriteMaskByte(REG_AUDIO_I2S_OUT1_CFG,0x08,u8Val<<3);
4037 break;
4038
4039 case AUDIO_I2S_SOURCE_CH:
4040 // No need ; Only select Group A in T3 .
4041 break;
4042
4043 case AUDIO_I2S_RXMODE:
4044 if(u8Val==I2S_SLAVE_MODE) //slave mode
4045 { //0x2C8C[2], 2CAE[13], 2CCE[15:13][1:0]
4046 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x00);
4047 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0x00);
4048 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0x20);
4049 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x00);
4050 }
4051 else //master mode
4052 {
4053 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SYNTH_EXPANDER, 0x04, 0x04);
4054 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG5+1, 0xA0, 0xA0);
4055 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST+1, 0xE0, 0xC0);
4056 HAL_AUDIO_WriteMaskByte(REG_AUDIO_ASIF_TST, 0x03, 0x03);
4057 }
4058 break;
4059
4060 case AUDIO_I2S_TXMODE:
4061 // Tx always Master Mode;
4062 break;
4063
4064 default:
4065 break;
4066 }
4067 }
4068
4069
4070
HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType,MS_BOOL bEnable)4071 static void HAL_AUDIO_DigitalOut_Set_Encode(AUDIO_ENCODE_TYPE eType, MS_BOOL bEnable)
4072 {
4073 switch(eType)
4074 {
4075 case DD_DDCO:
4076 if(bEnable == TRUE)
4077 {
4078 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x1 );
4079 }
4080 else
4081 {
4082 HAL_AUDIO_WriteMaskByte(0x2E95, 0x01, 0x0 );
4083 }
4084 break;
4085
4086 case DD_DDENCODE:
4087 if(bEnable == TRUE)
4088 {
4089 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x2 );
4090 }
4091 else
4092 {
4093 HAL_AUDIO_WriteMaskByte(0x2E95, 0x02, 0x0 );
4094 }
4095 break;
4096
4097 case DTS_ENCODE_2CH:
4098 case DTS_ENCODE_MULTI:
4099 case MP3_ENCODE:
4100 default:
4101 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Choosen Encoder not exist\n",__FUNCTION__);
4102 break;
4103 }
4104 }
4105
HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DSP_ID eDspID)4106 static void HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DSP_ID eDspID)
4107 {
4108 switch (ePath)
4109 {
4110 case DIGITAL_SPDIF_OUTPUT:
4111 {
4112 switch(eDspID)
4113 {
4114 case AUDIO_DSP_ID_R2:
4115 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x4);
4116 break;
4117 case AUDIO_DSP_ID_SND:
4118 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x8);
4119 break;
4120 case AUDIO_DSP_ID_DEC:
4121 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0xC, 0x0);
4122 break;
4123 default:
4124 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
4125 break;
4126 }
4127 }
4128 break;
4129
4130 case DIGITAL_HDMI_ARC_OUTPUT:
4131 {
4132 switch(eDspID)
4133 {
4134 case AUDIO_DSP_ID_R2:
4135 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
4136 break;
4137 case AUDIO_DSP_ID_SND:
4138 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
4139 break;
4140 case AUDIO_DSP_ID_DEC:
4141 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
4142 break;
4143 default:
4144 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
4145 break;
4146 }
4147 }
4148 break;
4149
4150 case DIGITAL_HDMI_OUTPUT:
4151 {
4152 switch(eDspID)
4153 {
4154 case AUDIO_DSP_ID_R2:
4155 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x4);
4156 break;
4157 case AUDIO_DSP_ID_SND:
4158 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x8);
4159 break;
4160 case AUDIO_DSP_ID_DEC:
4161 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0xC, 0x0);
4162 break;
4163 default:
4164 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - DEC ID %d not exist\n",__FUNCTION__,eDspID);
4165 break;
4166 }
4167 }
4168 break;
4169
4170 default:
4171 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
4172 break;
4173 }
4174
4175 }
4176
HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath,MS_BOOL bEnable)4177 static void HAL_AUDIO_DigitalOut_NPCMEnable(DIGITAL_OUTPUT_TYPE ePath, MS_BOOL bEnable)
4178 {
4179
4180 switch(ePath)
4181 {
4182 case DIGITAL_SPDIF_OUTPUT:
4183 if(bEnable == TRUE)
4184 {
4185 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
4186 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
4187 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x2);
4188 }
4189 else
4190 {
4191 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x0C, 0x00); /* Select DSP1 */
4192 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
4193 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
4194 }
4195 break;
4196
4197 case DIGITAL_HDMI_ARC_OUTPUT:
4198 if(bEnable == TRUE)
4199 {
4200 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4201 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4202 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
4203 }
4204 else
4205 {
4206 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
4207 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
4208 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4209 }
4210 break;
4211
4212 case DIGITAL_HDMI_OUTPUT:
4213 if(bEnable == TRUE)
4214 {
4215 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
4216 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
4217 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x2);
4218 }
4219 else
4220 {
4221 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x0C, 0x00); /* Select DSP1 */
4222 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x2, 0x0);
4223 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
4224 }
4225 break;
4226
4227 default:
4228 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Path %d not exist\n",__FUNCTION__,ePath);
4229 break;
4230 }
4231 }
4232 ////////////////////////////////////////////////////////////////////////////////
4233 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4234 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4235 /// @param <IN> \b u8Spdif_mode :
4236 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
4237 /// bit[1] = 0: PCM mode, 1: non-PCM mode
4238 /// bit[2] = 1: non-PCM NULL Payload
4239 /// @param <IN> \b u8Input_src 0 : DTV
4240 /// 1 : ATV
4241 /// 2 : HDMI
4242 /// 3 : ADC
4243 /// 4 : CardReader
4244 /// 5 : SPDIF
4245 /// @param <OUT> \b NONE :
4246 /// @param <RET> \b NONE :
4247 /// @param <GLOBAL> \b NONE :
4248 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSetting)4249 static void HAL_AUDIO_DigitalOut_SetDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSetting)
4250 {
4251 Digital_Out_Channel_Status_t stDigitalChannelStatus;
4252 memset(&stDigitalChannelStatus, 0x00, sizeof(Digital_Out_Channel_Status_t));
4253
4254 if (ePath == DIGITAL_SPDIF_OUTPUT)
4255 {
4256 _HAL_AUDIO_SPDIF_SetMute(TRUE);
4257 }
4258 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
4259 {
4260 //TODO: Mute HDMI , ARC
4261 }
4262 else if (ePath == DIGITAL_HDMI_OUTPUT)
4263 {
4264
4265 }
4266
4267 HAL_AUDIO_DigitalOut_GetChannelStatus(ePath, &stDigitalChannelStatus);
4268
4269 switch (stDigitalOutSetting->eDigitalOutfMode)
4270 {
4271 case DIGITAL_OUT_PCM:
4272 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, FALSE);
4273 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
4274 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
4275
4276 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
4277 break;
4278
4279 case DIGITAL_OUT_DOLBYDIGITAL:
4280 if (stDigitalOutSetting->u8R2NonPcmSetting == 0x01)
4281 {
4282 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
4283 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, TRUE);
4284 }
4285 else if (stDigitalOutSetting->u8R2NonPcmSetting == 0x02)
4286 {
4287 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
4288 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, TRUE);
4289 }
4290
4291 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4292 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
4293 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
4294 break;
4295
4296 case DIGITAL_OUT_DTS:
4297 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4298 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
4299 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
4300 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
4301 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
4302 break;
4303
4304 case DIGITAL_OUT_AAC_LC:
4305 stDigitalChannelStatus.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
4306 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDENCODE, FALSE);
4307 HAL_AUDIO_DigitalOut_Set_Encode(DD_DDCO, FALSE);
4308 HAL_AUDIO_DigitalOut_NPCM_SrcSwitch(ePath, stDigitalOutSetting->u8NonPcmPath);
4309 HAL_AUDIO_DigitalOut_NPCMEnable(ePath, TRUE);
4310 break;
4311
4312 case DIGITAL_OUT_NONE:
4313 default:
4314 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Digital Mode %d not exist\n",__FUNCTION__,stDigitalOutSetting->eDigitalOutfMode);
4315 break;
4316 }
4317
4318 HAL_AUDIO_DigitalOut_SetChannelStatus(ePath, &stDigitalChannelStatus);
4319 // Restore Digital out mode
4320 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), &stDigitalOutSetting, sizeof(DigitalOutSetting_t));
4321
4322 if (ePath == DIGITAL_SPDIF_OUTPUT)
4323 {
4324 if (g_AudioVars2->g_SPDIF_MuteStatus == FALSE)
4325 {
4326 _HAL_AUDIO_SPDIF_SetMute(FALSE);
4327 }
4328 }
4329 else
4330 {
4331 //TODO: um-Mute HDMI , ARC
4332 }
4333
4334 }
4335
4336
4337
4338 //static MS_BOOL HAL_AUDIO_DigitalOut_GetDataSource(AUDIO_OUTPORT_SOURCE_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE *retOutputType, AUDIO_DSP_ID *retNcmPath)
4339
HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath,DigitalOutSetting_t * stDigitalOutSegtting)4340 static MS_BOOL HAL_AUDIO_DigitalOut_DetermineDataPath(DIGITAL_OUTPUT_TYPE ePath, DigitalOutSetting_t *stDigitalOutSegtting)
4341 {
4342 AUDIO_DSP_CODE_TYPE SourceDspCodeType = AU_DVB_STANDARD_INVALID;
4343 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
4344 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
4345
4346 stDigitalOutSegtting->eSourceType = g_AudioVars2->eAudioSource;
4347 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
4348 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
4349
4350 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s() - eDigitalOutfMode = %x, eNonPcmPath = %x , Source = %x, R2NonPcmSetting = %x\n\r", \
4351 __FUNCTION__, \
4352 stDigitalOutSegtting->eDigitalOutfMode, \
4353 stDigitalOutSegtting->u8NonPcmPath, \
4354 stDigitalOutSegtting->eSourceType, \
4355 stDigitalOutSegtting->u8R2NonPcmSetting);
4356
4357 switch (stDigitalOutSegtting->eDigitalOutfMode)
4358 {
4359 case DIGITAL_OUT_PCM:
4360 {
4361 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4362 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC;
4363 break;
4364 }
4365
4366 case DIGITAL_OUT_DOLBYDIGITAL:
4367 {
4368 switch (stDigitalOutSegtting->eSourceType)
4369 {
4370 case E_AUDIO_INFO_HDMI_IN:
4371 {
4372 if (bIsNonPCMInDec2)
4373 {
4374 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE)) &&
4375 (Dsp2CodeType == AU_DVB_STANDARD_AC3 || Dsp2CodeType == AU_DVB_STANDARD_AC3P))
4376 {
4377 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP2 */
4378 }
4379 }
4380 else if ((Dsp1CodeType == AU_DVB_STANDARD_AC3) ||
4381 (Dsp1CodeType == AU_DVB_STANDARD_AC3P))
4382 {
4383 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4384 }
4385 break;
4386 }
4387
4388 case E_AUDIO_INFO_DTV_IN:
4389 case E_AUDIO_INFO_MM_IN:
4390 case E_AUDIO_INFO_GAME_IN:
4391 {
4392 SourceDspCodeType = Dsp1CodeType;
4393
4394 switch(SourceDspCodeType)
4395 {
4396 case AU_DVB_STANDARD_AAC:
4397 case AU_DVB_STANDARD_MS10_DDT:
4398 {
4399 if ((!MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_MS10_DDT)) &&
4400 (!MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DDE)))
4401 {
4402 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4403 }
4404 else
4405 {
4406 if (HAL_MAD_Read_DSP_sram(DSP1PmAddr_smpRate, DSP_MEM_TYPE_PM) == 44100)
4407 {
4408 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4409 }
4410 else
4411 {
4412 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_R2; /* R2 */
4413 stDigitalOutSegtting->u8R2NonPcmSetting = (SourceDspCodeType == AU_DVB_STANDARD_AAC) ? 0x01 : 0x02; /* DDCO : 0x2E95[0], DDEnc : 0x2E95[1] */
4414 }
4415 }
4416
4417 break;
4418 }
4419
4420 case AU_DVB_STANDARD_MS10_DDC:
4421 case AU_DVB_STANDARD_AC3:
4422 case AU_DVB_STANDARD_AC3P:
4423 {
4424 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4425 break;
4426 }
4427
4428 default:
4429 {
4430 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4431 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4432 break;
4433 }
4434
4435 }
4436
4437 break;
4438 }
4439
4440 case E_AUDIO_INFO_ATV_IN:
4441 case E_AUDIO_INFO_ADC_IN:
4442 case E_AUDIO_INFO_KTV_IN:
4443 default:
4444 {
4445 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4446 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4447 break;
4448 }
4449 }
4450 break;
4451 }
4452
4453 case DIGITAL_OUT_DTS:
4454 {
4455 switch (stDigitalOutSegtting->eSourceType)
4456 {
4457 case E_AUDIO_INFO_HDMI_IN:
4458 {
4459 if (bIsNonPCMInDec2)
4460 {
4461 if (Dsp2CodeType == AU_DVB2_STANDARD_DTS) // Need check
4462 {
4463 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_SND; /* DSP2 */
4464 }
4465 }
4466 else if (Dsp1CodeType == AU_DVB_STANDARD_DTS)
4467 {
4468 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4469 }
4470 break;
4471 }
4472
4473 case E_AUDIO_INFO_MM_IN:
4474 case E_AUDIO_INFO_GAME_IN:
4475 {
4476 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_DTS;
4477 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4478 break;
4479 }
4480
4481 default:
4482 {
4483 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4484 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4485 break;
4486 }
4487 }
4488
4489 break;
4490 }
4491
4492 case DIGITAL_OUT_AAC_LC:
4493 {
4494 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4495 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4496 break;
4497 }
4498
4499 case DIGITAL_OUT_NONE:
4500 default:
4501 {
4502 stDigitalOutSegtting->eDigitalOutfMode = DIGITAL_OUT_PCM;
4503 stDigitalOutSegtting->u8NonPcmPath = AUDIO_DSP_ID_DEC; /* DSP1 */
4504 break;
4505 }
4506
4507 }
4508
4509 return TRUE;
4510 }
4511
4512 ////////////////////////////////////////////////////////////////////////////////
4513 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4514 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4515 /// @param <IN> \b
4516 /// @param <IN> \b
4517 /// @param <OUT> \b NONE :
4518 /// @param <RET> \b NONE :
4519 /// @param <GLOBAL> \b NONE :
4520 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath,AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)4521 void HAL_AUDIO_SetDigitalOut(DIGITAL_OUTPUT_TYPE ePath, AUDIO_DIGITAL_OUTPUT_TYPE eDigitalMode)
4522 {
4523
4524 HALAUDIO_CHECK_SHM_INIT;
4525
4526 //TODO: add HDMI/ARC digital out status
4527
4528 // Set Digital mode to Digital out Status structure
4529 DigitalOutSetting_t stTempDigitalOutStatus;
4530 stTempDigitalOutStatus.eDigitalOutfMode = eDigitalMode;
4531 stTempDigitalOutStatus.eSourceType = E_AUDIO_INFO_DTV_IN; // Temp initial value
4532 stTempDigitalOutStatus.u8NonPcmPath = AUDIO_DSP_ID_ALL;
4533 stTempDigitalOutStatus.u8R2NonPcmSetting = 0x00;
4534 stTempDigitalOutStatus.eGroup = E_CONNECT_NULL;
4535
4536 if (ePath == DIGITAL_SPDIF_OUTPUT)
4537 {
4538 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.SpdifOut;
4539 }
4540 else if (ePath == DIGITAL_HDMI_ARC_OUTPUT)
4541 {
4542 stTempDigitalOutStatus.eGroup = g_AudioVars2->AudioOutputSourceInfo.ArcOut;
4543 }
4544
4545 //Determin Data Path
4546 HAL_AUDIO_DigitalOut_DetermineDataPath(ePath, &stTempDigitalOutStatus);
4547
4548 // if setting is difference to previous, set digital out mode
4549 if ((stTempDigitalOutStatus.eDigitalOutfMode != g_AudioVars2->stDigitalOutSetting[ePath].eDigitalOutfMode) ||
4550 (stTempDigitalOutStatus.eSourceType != g_AudioVars2->stDigitalOutSetting[ePath].eSourceType) ||
4551 (stTempDigitalOutStatus.u8NonPcmPath != g_AudioVars2->stDigitalOutSetting[ePath].u8NonPcmPath) ||
4552 (stTempDigitalOutStatus.u8R2NonPcmSetting != g_AudioVars2->stDigitalOutSetting[ePath].u8R2NonPcmSetting) ||
4553 (stTempDigitalOutStatus.eGroup != g_AudioVars2->stDigitalOutSetting[ePath].eGroup))
4554
4555 {
4556 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s() - eDigitalOutfMode = %x, eNonPcmPath = %x\n\r", \
4557 __FUNCTION__, \
4558 stTempDigitalOutStatus.eDigitalOutfMode, \
4559 stTempDigitalOutStatus.u8NonPcmPath);
4560
4561 HAL_AUDIO_DigitalOut_SetDataPath(ePath, &stTempDigitalOutStatus);
4562 }
4563 }
4564
4565 ////////////////////////////////////////////////////////////////////////////////
4566 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
4567 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4568 /// @param <IN> \b eType :
4569 /// @param <OUT> \b NONE :
4570 /// @param <RET> \b NONE :
4571 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)4572 MS_BOOL HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
4573 {
4574 MS_BOOL ret = FALSE;
4575
4576 HALAUDIO_CHECK_SHM_INIT;
4577
4578 switch (ePath)
4579 {
4580 case DIGITAL_SPDIF_OUTPUT:
4581 {
4582
4583 // Copy protection
4584 //C bit
4585 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
4586 // L bit
4587 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
4588
4589 // PCM format
4590 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
4591 if(g_u32bDTSCD == 1)
4592 {
4593 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS0 ,0x40, 0x00);
4594 }
4595
4596 // Category
4597 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
4598
4599 // Source number
4600 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
4601
4602 // Channel number
4603 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
4604
4605 // Sampling rate
4606 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
4607
4608 // Clock precision
4609 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
4610
4611 // Word Length
4612 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
4613
4614 // Original sampling rate
4615 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
4616
4617 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
4618 {
4619 if(g_u32bDTSCD == 1)
4620 {
4621 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
4622 }
4623 else
4624 {
4625 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x80);
4626 }
4627 }
4628 else
4629 {
4630 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x80, 0x00);
4631 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
4632 }
4633 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00); //Tx1 Toggle bit[14]
4634 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x40);
4635 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x40, 0x00);
4636 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
4637 break;
4638 }
4639
4640 case DIGITAL_HDMI_ARC_OUTPUT:
4641 {
4642 // Copy protection
4643 //C bit
4644 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x20, stChannelStatus->stCopyRight.CBit << 5);
4645 // L bit
4646 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 ,0x01, stChannelStatus->stCopyRight.LBit);
4647
4648 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0xDF, stChannelStatus->u8PcmFormatControl);
4649 if(g_u32bDTSCD == 1)
4650 {
4651 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS0 ,0x40, 0x00);
4652 }
4653
4654 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS1 , 0xFE, stChannelStatus->u8Category);
4655
4656 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0xF0, stChannelStatus->u8SourceNumber);
4657
4658 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS2, 0x0F, stChannelStatus->u8ChannelNumber);
4659
4660 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, stChannelStatus->u8SamplingRate);
4661
4662 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0x0F, stChannelStatus->u8ClockPrecision);
4663
4664 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0xF0, stChannelStatus->u8WordLength);
4665
4666 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS4 , 0x0F, stChannelStatus->u8OriginalSamplingRate);
4667
4668 if ((stChannelStatus->u8PcmFormatControl & SPDIF_CS_FORMAT_NONPCM) == SPDIF_CS_FORMAT_NONPCM)
4669 {
4670 if(g_u32bDTSCD == 1)
4671 {
4672 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
4673 }
4674 else
4675 {
4676 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x80);
4677 }
4678 }
4679 else
4680 {
4681 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x80, 0x00);
4682 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CS3 , 0xF0, SPDIF_CS_FS_48K);
4683 }
4684
4685 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x00); //Tx2 Toggle bit[12]
4686 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x10);
4687 HAL_AUDIO_WriteMaskByte(REG_SPDIFTX_CHANNEL_STATUS_TOGGLE, 0x10, 0x00);
4688 memcpy(&(g_AudioVars2->stDigitalOutChannelStatus[ePath]), stChannelStatus, sizeof(Digital_Out_Channel_Status_t));
4689 break;
4690 }
4691
4692 default:
4693 {
4694 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() - Invalid SPDIF Path\n",__FUNCTION__);
4695 break;
4696 }
4697 }
4698
4699 return ret;
4700 }
4701
4702 ////////////////////////////////////////////////////////////////////////////////
4703 /// @brief \b Function \b Name: HAL_AUDIO_Digital_Out_SetChannelStatus()
4704 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
4705 /// @param <IN> \b eType :
4706 /// @param <OUT> \b NONE :
4707 /// @param <RET> \b NONE :
4708 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath,Digital_Out_Channel_Status_t * stChannelStatus)4709 MS_BOOL HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_OUTPUT_TYPE ePath, Digital_Out_Channel_Status_t *stChannelStatus)
4710 {
4711 MS_BOOL ret = FALSE;
4712
4713 HALAUDIO_CHECK_SHM_INIT;
4714
4715 if (stChannelStatus == NULL)
4716 {
4717 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : stChannelStatus shouldn't be NULL !!!\n", __FUNCTION__);
4718 }
4719 else
4720 {
4721 memcpy(stChannelStatus, &(g_AudioVars2->stDigitalOutChannelStatus[ePath]), sizeof(Digital_Out_Channel_Status_t));
4722 ret = TRUE;
4723 }
4724
4725 return ret;
4726 }
4727
4728 ///-----------------------------------------------------------------------------
4729 ////////////////////////////////////////////////////////////////////////////////
4730 ////////////////////////////////////////////////////////////////////////////////
4731 ///
4732 /// AUDIO SPDIF Relational Hal Function
4733 ///
4734 ////////////////////////////////////////////////////////////////////////////////
4735 ////////////////////////////////////////////////////////////////////////////////
4736 ///-----------------------------------------------------------------------------
4737 ////////////////////////////////////////////////////////////////////////////////
4738 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_HWEN() @@Cathy
4739 /// @brief \b Function \b Description: This routine is used to enable S/PDIF output (Hardware)
4740 /// @param <IN> \b bEnable: 0--Disable S/PDIF out
4741 /// 1--Enable S/PDIF out
4742 /// @param <OUT> \b NONE :
4743 /// @param <RET> \b NONE :
4744 /// @param <GLOBAL> \b NONE :
4745 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)4746 void _HAL_AUDIO_SPDIF_HWEN(MS_BOOL bEnable)
4747 {
4748 if(bEnable)
4749 {
4750 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x80);
4751 }
4752 else
4753 {
4754 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x80, 0x00);
4755 }
4756 }
4757
4758 ////////////////////////////////////////////////////////////////////////////////
4759 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_SetMute() @@KH
4760 /// @brief \b Function \b Description: This routine is used to mute S/PDIF output(by DSP)
4761 /// @param <IN> \b bEnMute : 0--Disable mute
4762 /// 1--Enable mute
4763 /// @param <OUT> \b NONE :
4764 /// @param <RET> \b NONE :
4765 /// @param <GLOBAL> \b NONE :
4766 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)4767 void _HAL_AUDIO_SPDIF_SetMute(MS_BOOL bEnMute)
4768 {
4769 MS_BOOL spdif_mute_status = FALSE;
4770 MS_U8 spdif_timecnt = 0;
4771
4772 HALAUDIO_CHECK_SHM_INIT;
4773
4774 /* check current status according to SPDIF Software mute bit */
4775 spdif_mute_status = (((HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL) & 0x01) > 0) ? TRUE : FALSE);
4776
4777 /* apply change only when it's a different status from current status */
4778 if (spdif_mute_status != bEnMute)
4779 {
4780 if (bEnMute == TRUE)
4781 {
4782 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x80); //Fading-out mute
4783 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x01); // Software mute
4784 }
4785 else
4786 {
4787 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x01, 0x00); // Software unmute
4788 for (spdif_timecnt = 0; spdif_timecnt < 30; spdif_timecnt++)
4789 {
4790 AUDIO_DELAY1MS(1);
4791 }
4792 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC+1, 0x80, 0x00); //Fading-in unmute
4793 }
4794 }
4795 }
4796
4797 ////////////////////////////////////////////////////////////////////////////////
4798 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_ByPassChannel() @@Need_Modify
4799 /// @brief \b Function \b Description: ByPass the SPDIF channel (CH4)
4800 /// @param <IN> \b \b enable : TRUE --BYPASS CH4
4801 /// FALSE--OPEN CH4
4802 /// @param <OUT> \b NONE :
4803 /// @param <RET> \b NONE :
4804 /// @param <GLOBAL> \b NONE :
4805 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)4806 void _HAL_AUDIO_SPDIF_ByPassChannel(MS_BOOL bEnable)
4807 {
4808 bEnable = bEnable;
4809 }
4810
4811 ////////////////////////////////////////////////////////////////////////////////
4812 /// @brief \b Function \b Name: _HAL_AUDIO_Get_SourceIndex() @@Ken
4813 /// @brief \b Function \b Description: Get Source Decoder index
4814 /// @param <IN> \b \b eAudioSource: E_AUDIO_INFO_DTV_IN -- DTV Source
4815 /// E_AUDIO_INFO_HDMI_IN -- HDMI Source
4816 /// E_AUDIO_INFO_MM_IN -- MM Source
4817 /// @param <OUT> \b NONE :
4818 /// @param <RET> \b AUDIO_DEC_ID :
4819 /// AUDIO_DEC_ID: AU_DEC_ID1 -- 0
4820 /// AU_DEC_ID2 -- 1
4821 /// AU_DEC_ID3 -- 2
4822 /// Error code: -1 -- invalid Decoder index
4823 /// -2 -- invalid source
4824 /// -3 -- No connect
4825 /// @param <GLOBAL> \b NONE :
4826 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_Get_SourceDecoderIndex(AUDIO_SOURCE_INFO_TYPE eAudioSource)4827 AUDIO_DEC_ID _HAL_AUDIO_Get_SourceDecoderIndex(AUDIO_SOURCE_INFO_TYPE eAudioSource)
4828 {
4829 MS_U32 u32DecIndex = 0;
4830 MS_U32 u32CurrDecIndex = AU_DEC_MAX;
4831 AUDIO_DEC_ID *pDecPriority = NULL;
4832
4833 switch(eAudioSource)
4834 {
4835 case E_AUDIO_INFO_DTV_IN:
4836 {
4837 pDecPriority = DTVDecPriority;
4838 break;
4839 }
4840
4841 case E_AUDIO_INFO_HDMI_IN:
4842 {
4843 pDecPriority = HDMIDecPriority;
4844 break;
4845 }
4846
4847 case E_AUDIO_INFO_MM_IN:
4848 {
4849 pDecPriority = MMDecPriority;
4850 break;
4851 }
4852
4853 default:
4854 {
4855 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
4856 return AU_DEC_INVALID;
4857 }
4858 }
4859
4860 for (u32DecIndex = 0; u32DecIndex < AU_DEC_MAX;u32DecIndex++)
4861 {
4862 if(g_AudioVars2->AudioDecStatus[pDecPriority[u32DecIndex]].eSourceType == E_AUDIO_INFO_DTV_IN)
4863 {
4864 u32CurrDecIndex = pDecPriority[u32DecIndex];
4865 break;
4866 }
4867 }
4868
4869 if (u32CurrDecIndex == AU_DEC_MAX)
4870 {
4871 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() u32CurrDecIndex %d - Invalid u32DecIndex\n",__FUNCTION__, u32CurrDecIndex);
4872 return AU_DEC_INVALID;
4873 }
4874
4875 if (g_AudioVars2->AudioDecStatus[u32CurrDecIndex].bConnect == FALSE)
4876 {
4877 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() Decoder%d Not Connect\n",__FUNCTION__, u32CurrDecIndex);
4878 return AU_DEC_INVALID;
4879 }
4880
4881 return u32CurrDecIndex;
4882
4883 }
4884
4885
4886 ////////////////////////////////////////////////////////////////////////////////
4887 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetMode()
4888 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
4889 /// @param <IN> \b u8Spdif_mode :
4890 /// bit[0] = 0: spdif enable, 1: spdif disable (Se-DSP)
4891 /// bit[1] = 0: PCM mode, 1: non-PCM mode
4892 /// bit[2] = 1: non-PCM NULL Payload
4893 /// @param <IN> \b u8Input_src 0 : DTV
4894 /// 1 : ATV
4895 /// 2 : HDMI
4896 /// 3 : ADC
4897 /// 4 : CardReader
4898 /// 5 : SPDIF
4899 /// @param <OUT> \b NONE :
4900 /// @param <RET> \b NONE :
4901 /// @param <GLOBAL> \b NONE :
4902 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode,MS_U8 u8Input_src)4903 void HAL_AUDIO_SPDIF_SetMode(MS_U8 u8Spdif_mode, MS_U8 u8Input_src)
4904 {
4905 // Multiple npcm source, still need total rework
4906 AUDIO_SOURCE_INFO_TYPE eAudioSource = -1;
4907 MS_U8 u8SpdifMode = ((u8Spdif_mode == SPDIF_OUT_NONE) ? SPDIF_OUT_PCM : u8Spdif_mode);
4908 MS_U8 u8R2SpdifMode = ((u8SpdifMode == SPDIF_OUT_PCM) ? 1 : 2);
4909 MS_U8 u8MainDecodeId = 0;
4910 MS_U8 u8ChannelMuxId = 0; // decoder1
4911 AUDIO_DSP_CODE_TYPE MainDspCodeType = AU_DVB_STANDARD_INVALID;
4912 AUDIO_DSP_CODE_TYPE Dsp1CodeType = AU_DVB_STANDARD_INVALID;
4913 AUDIO_DSP_CODE_TYPE Dsp2CodeType = AU_DVB_STANDARD_INVALID;
4914 MS_U32 u32bDTSCD = 0;
4915 MS_U32 u32DTSTranscodeFlag = 0;
4916 MS_U8 Digital_Out_DD_Support = 0;
4917 MS_U8 Digital_Out_DDP_Support = 0;
4918 MS_U8 Digital_Out_DTS_Support = 0;
4919 MS_U8 Digital_Out_AAC_Support = 0;
4920 MS_U32 u32HDMITxSamplingRate = 0;
4921 MS_U32 u32SPDIFTxSamplingRate = 0;
4922 MS_U64 u64DecSamplingRate = 0;
4923 static MS_U32 u32bPreDTSCD = 0xFF;
4924 static MS_U32 u32PreHDMITxSamplingRate = 0;
4925 static MS_U32 u32PreSPDIFTxSamplingRate = 0;
4926 MS_S32 ddp_enc_enable;
4927 MS_U32 u32HdmiArcSpecifiedOutputCodec = DIGITAL_OUTPUT_CODEC_NOT_SPECIFIED;
4928 MS_U32 u32DecIndex = 0;
4929
4930 HALAUDIO_CHECK_SHM_INIT;
4931
4932 UNUSED(u8Input_src);
4933 eAudioSource = g_AudioVars2->eAudioSource;
4934 Dsp1CodeType = g_AudioVars2->g_DspCodeType;
4935 Dsp2CodeType = g_AudioVars2->g_Dsp2CodeType;
4936 Digital_Out_DD_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DD].support_codec;
4937 Digital_Out_DDP_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DDP].support_codec;
4938 Digital_Out_DTS_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_DTS].support_codec;
4939 Digital_Out_AAC_Support = g_AudioVars2->stDigitalOutCodecCapability[0][CODEC_AAC].support_codec;
4940 u32HdmiArcSpecifiedOutputCodec = g_AudioVars2->g_AudioSpecifiedDigitalOutput.u32HdmiArcOutputCodec;
4941
4942 MainDspCodeType = Dsp1CodeType;
4943
4944 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: u8Spdif_mode = %d, eAudioSource = %d, u8Dsp1CodeType = %d, u8Dsp2CodeType = %d, u8Input_src = %d\r\n", __FUNCTION__, u8Spdif_mode, eAudioSource, u8Dsp1CodeType, u8Dsp2CodeType, u8Input_src);
4945
4946 /* Configure SPDIF's Output Setting */
4947 ddp_enc_enable = 0;
4948 switch(eAudioSource)
4949 {
4950 case E_AUDIO_INFO_DTV_IN:
4951 case E_AUDIO_INFO_MM_IN:
4952 case E_AUDIO_INFO_GAME_IN:
4953 {
4954 if (((eAudioSource == E_AUDIO_INFO_MM_IN) || (eAudioSource == E_AUDIO_INFO_GAME_IN)) &&
4955 (HAL_MAD_GetDecCmd(DVB_Audio_Decoder2) == AU_DVB_DECCMD_PLAYFRAME_GS))
4956 {
4957 MainDspCodeType = Dsp2CodeType;
4958
4959 u8MainDecodeId = 1; //DEC2
4960 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC2_sampleRate);
4961 }
4962 else
4963 {
4964 u8MainDecodeId = 0; //DEC1
4965 u64DecSamplingRate = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_sampleRate);
4966
4967 if (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_STOP)
4968 {
4969 u8SpdifMode = SPDIF_OUT_PCM;
4970 break;
4971 }
4972 }
4973
4974 switch(MainDspCodeType)
4975 {
4976 case AU_DVB_STANDARD_AAC:
4977 case AU_DVB_STANDARD_MS10_DDT:
4978 {
4979 if (g_AudioVars2->DolbyEncFlag != 1)
4980 {
4981 u8SpdifMode = SPDIF_OUT_PCM;
4982 }
4983 #if (StereoAACOutputPCM)
4984 else if (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_acmod) == AUD_CH_MODE_STEREO)
4985 {
4986 u8SpdifMode = SPDIF_OUT_PCM;
4987 }
4988 #endif
4989 else
4990 {
4991 if ((u8SpdifMode == SPDIF_OUT_NONPCM) ||
4992 (u8SpdifMode == SPDIF_OUT_TRANSCODE))
4993 {
4994 /* 0: default, 1: support, 2: not support */
4995 if (Digital_Out_DD_Support == 2)
4996 {
4997 u8SpdifMode = SPDIF_OUT_PCM;
4998 }
4999 else if ((MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_B)||
5000 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_B_WO_AAC)||
5001 MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_D)||
5002 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_D_WO_AAC))&& (Digital_Out_DDP_Support == 1))
5003 {
5004 if (u32HdmiArcSpecifiedOutputCodec != DIGITAL_OUTPUT_CODEC_AC3)
5005 {
5006 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x20); //enable DDP encoder
5007 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, u8MainDecodeId, 1, 0);
5008 ddp_enc_enable = 1;
5009 }
5010 }
5011 else if ( u64DecSamplingRate < 4) //AAC SampleRate<16k
5012 {
5013 u8SpdifMode = SPDIF_OUT_PCM;
5014 }
5015
5016 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 0, 0);
5017 }
5018 else if (u8SpdifMode == SPDIF_OUT_BYPASS) // AAC Bypass
5019 {
5020 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DOLBY_AAC_BYPASS, u8MainDecodeId, 1, 0);
5021 }
5022 }
5023 break;
5024 }
5025
5026 case AU_DVB_STANDARD_AC3:
5027 case AU_DVB_STANDARD_AC3P:
5028 case AU_DVB_STANDARD_MS10_DDC:
5029 case AU_DVB2_ENCODE_MS10_DDE:
5030 {
5031 /* 0: default, 1: support, 2: not support */
5032 if (Digital_Out_DD_Support == 2)
5033 {
5034 u8SpdifMode = SPDIF_OUT_PCM;
5035 }
5036 /* 0: default, 1: support, 2: not support */
5037 else if (Digital_Out_DDP_Support == 1)
5038 {
5039 //if(u8SpdifMode != SPDIF_OUT_TRANSCODE)
5040 if(u8SpdifMode == SPDIF_OUT_BYPASS)
5041 {
5042 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
5043 }
5044 else
5045 {
5046 if ((MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_B)||
5047 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_B_WO_AAC)||
5048 MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_D)||
5049 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_D_WO_AAC))&& (u8SpdifMode == SPDIF_OUT_NONPCM || u8SpdifMode == SPDIF_OUT_TRANSCODE))
5050 {
5051 if (u32HdmiArcSpecifiedOutputCodec != DIGITAL_OUTPUT_CODEC_AC3)
5052 {
5053 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x20); //enable DDP encoder
5054 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, u8MainDecodeId, 1, 0);
5055 ddp_enc_enable = 1;
5056 }
5057 }
5058 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
5059 }
5060 }
5061 else
5062 {
5063 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
5064 }
5065 break;
5066 }
5067
5068 case AU_DVB_STANDARD_DTS:
5069 case AU_DVB_STANDARD_DTSLBR:
5070 {
5071 /* 0: disable, 1: bypass /convert, 2: transcoder, 3: pcm */
5072 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
5073 if (u32DTSTranscodeFlag == 3)
5074 {
5075 u8SpdifMode = SPDIF_OUT_PCM;
5076 }
5077
5078 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) &&
5079 (u32DTSTranscodeFlag == 1))
5080 {
5081 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
5082 }
5083
5084 /* 0: default, 1: support, 2: not support */
5085 if (Digital_Out_DTS_Support == 2)
5086 {
5087 u8SpdifMode = SPDIF_OUT_PCM;
5088 }
5089
5090 break;
5091 }
5092
5093 default:
5094 {
5095 u8SpdifMode = SPDIF_OUT_PCM;
5096 break;
5097 }
5098 }
5099
5100 break;
5101 }
5102
5103 case E_AUDIO_INFO_ATV_IN:
5104 case E_AUDIO_INFO_ADC_IN:
5105 case E_AUDIO_INFO_KTV_IN:
5106 {
5107 u8SpdifMode = SPDIF_OUT_PCM;
5108 break;
5109 }
5110
5111 case E_AUDIO_INFO_HDMI_IN:
5112 {
5113 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE))
5114 {
5115 MainDspCodeType = Dsp2CodeType;
5116 u8MainDecodeId = 1; //DEC2
5117 }
5118 else
5119 {
5120 u8MainDecodeId = 0; //DEC1
5121 }
5122
5123 if (HAL_AUDIO_HDMI_NonpcmMonitor() == FALSE)
5124 {
5125 u8SpdifMode = SPDIF_OUT_PCM;
5126 }
5127 else
5128 {
5129 switch(MainDspCodeType)
5130 {
5131 case AU_DVB_STANDARD_AC3:
5132 case AU_DVB_STANDARD_AC3P:
5133 case AU_DVB_STANDARD_MS10_DDC:
5134 case AU_DVB2_ENCODE_MS10_DDE:
5135 {
5136 /* 0: default, 1: support, 2: not support */
5137 if (Digital_Out_DD_Support == 2)
5138 {
5139 u8SpdifMode = SPDIF_OUT_PCM;
5140 }
5141 /* 0: default, 1: support, 2: not support */
5142 else if (Digital_Out_DDP_Support == 1)
5143 {
5144 if(u8SpdifMode == SPDIF_OUT_BYPASS)
5145 {
5146 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 1, u8MainDecodeId);
5147 }
5148 else
5149 {
5150 if ((MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_B)||
5151 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_B_WO_AAC)||
5152 MDrv_AUTH_IPCheck(AU_DVB_AUTHBIT_DOLBY_MS12_D)||
5153 MDrv_AUTH_IPCheck(AU_DVB2_AUTHBIT_DOLBY_MS12_D_WO_AAC)) && (u8SpdifMode == SPDIF_OUT_NONPCM || u8SpdifMode == SPDIF_OUT_TRANSCODE))
5154 {
5155 if (u32HdmiArcSpecifiedOutputCodec != DIGITAL_OUTPUT_CODEC_AC3)
5156 {
5157 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x20); //enable DDP encoder
5158 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, u8MainDecodeId, 1, 0);
5159 ddp_enc_enable = 1;
5160 }
5161 }
5162 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
5163 }
5164 }
5165 else
5166 {
5167 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_hdmiTxBypass_enable, 0, u8MainDecodeId);
5168 }
5169 break;
5170 }
5171
5172 case AU_DVB_STANDARD_DTS:
5173 {
5174 /* 0: disable, 1: bypass /convert, 2: transcoder, 3: pcm */
5175 u32DTSTranscodeFlag = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_TRANSCODE_FLAG, u8MainDecodeId);
5176 if (u32DTSTranscodeFlag == 3)
5177 {
5178 u8SpdifMode = SPDIF_OUT_PCM;
5179 }
5180
5181 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) &&
5182 (u32DTSTranscodeFlag == 1))
5183 {
5184 u32bDTSCD = HAL_MAD_GetDTSInfo(Audio_DTS_infoType_CD_MODE);
5185 }
5186
5187 /* 0: default, 1: support, 2: not support */
5188 if (Digital_Out_DTS_Support == 2)
5189 {
5190 u8SpdifMode = SPDIF_OUT_PCM;
5191 }
5192 break;
5193 }
5194
5195 default:
5196 {
5197 u8SpdifMode = SPDIF_OUT_PCM;
5198 break;
5199 }
5200 }
5201 }
5202
5203 break;
5204 }
5205
5206 default:
5207 {
5208 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid eAudioSource(%d)!\r\n", __FUNCTION__, eAudioSource);
5209 break;
5210 }
5211 }
5212
5213 if(ddp_enc_enable == 0)
5214 {
5215 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x20, 0x0); //disable DDP encoder
5216 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_DDP_ENCODE_EN, u8MainDecodeId, 0, 0);
5217 }
5218
5219 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: u8MainDspCodeType = %d, u8SpdifMode = %d\r\n", __FUNCTION__, u8MainDspCodeType, u8SpdifMode);
5220
5221 switch (eAudioSource)
5222 {
5223 case E_AUDIO_INFO_HDMI_IN:
5224 {
5225 if ((HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) != 0))
5226 {
5227 u8ChannelMuxId = 0x2; // decoder3
5228 }
5229 break;
5230 }
5231
5232 case E_AUDIO_INFO_DTV_IN:
5233 {
5234 u32DecIndex = _HAL_AUDIO_Get_SourceDecoderIndex(E_AUDIO_INFO_DTV_IN);
5235
5236 if (u32DecIndex == AU_DEC_ID1)
5237 {
5238 u8ChannelMuxId = 0x0; // decoder1
5239 }
5240 else if (u32DecIndex == AU_DEC_ID3)
5241 {
5242 u8ChannelMuxId = 0x2; // decoder1
5243 }
5244
5245 break;
5246 }
5247
5248 case E_AUDIO_INFO_MM_IN:
5249 case E_AUDIO_INFO_GAME_IN:
5250 {
5251 if ((HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAYFILETSP) || (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAYFILE)
5252 || (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAYFRAME) || (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAYFRAME_STAGE)
5253 || (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAYFILE2_PTS) || (HAL_MAD_GetDecCmd(DVB_Audio_Decoder1) == AU_DVB_DECCMD_PLAY_AD)
5254 )
5255 {
5256 u8ChannelMuxId = 0x0; // decoder1
5257 }
5258 else
5259 {
5260 u8ChannelMuxId = 0x2; // decoder3
5261 }
5262
5263 break;
5264 }
5265
5266 default:
5267 {
5268 break;
5269 }
5270 }
5271
5272 /* set multi channel input source to current decoder */
5273 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH1_CFG, 0x07, u8ChannelMuxId);
5274 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH2_CFG, 0x07, u8ChannelMuxId);
5275 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH3_CFG, 0x07, u8ChannelMuxId);
5276 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH4_CFG, 0x07, u8ChannelMuxId);
5277
5278 if(u8SpdifMode == SPDIF_OUT_PCM)
5279 {
5280 u32HDMITxSamplingRate = 48000;
5281 u32SPDIFTxSamplingRate = 48000;
5282 }
5283 else
5284 {
5285 u32HDMITxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, u8MainDecodeId);
5286 u32SPDIFTxSamplingRate = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, u8MainDecodeId);
5287 }
5288
5289 if ((_HAL_AUDIO_SPDIF_GetMode() == u8SpdifMode) &&
5290 (g_AudioVars2->g_PreMainDecodeId == u8MainDecodeId) &&
5291 (g_AudioVars2->g_PreMainDspCodeType == MainDspCodeType) &&
5292 (u32PreHDMITxSamplingRate == u32HDMITxSamplingRate) &&
5293 (u32PreSPDIFTxSamplingRate == u32SPDIFTxSamplingRate))
5294 {
5295 if ((MainDspCodeType == AU_DVB_STANDARD_DTS) ||
5296 (MainDspCodeType == AU_DVB_STANDARD_DTSLBR))
5297 {
5298 if (u32bPreDTSCD == u32bDTSCD)
5299 {
5300 /* In DTS/DTS-LBR case, if DTS-CD information is same, no need to to change SPDIF setting */
5301 return;
5302 }
5303 }
5304 else
5305 {
5306 /* No need to change SPDIF setting */
5307 return;
5308 }
5309 }
5310
5311 MS_BOOL retTx1, retTx2;
5312 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
5313 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
5314 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
5315 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5316 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5317
5318
5319 if (retTx1 == FALSE || retTx2 == FALSE)
5320 {
5321 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
5322 return;
5323 }
5324
5325 /* Mute SPDIF before changing setting */
5326 _HAL_AUDIO_SPDIF_SetMute(TRUE);
5327
5328 /* Apply UI's SPDIF setting to Audio R2 */
5329 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC1, u8R2SpdifMode, 0);
5330 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_SPDIF_TYPE, ADEC2, u8R2SpdifMode, 0);
5331
5332 HAL_AUR2_WriteByte(REG_R2_HDMI_NONPCM_PATH, u8MainDecodeId);
5333
5334 /* Apply SPDIF's Output Setting */
5335 switch (u8SpdifMode)
5336 {
5337 case SPDIF_OUT_NONPCM:
5338 case SPDIF_OUT_BYPASS:
5339 case SPDIF_OUT_TRANSCODE:
5340 {
5341 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "HAL SPDIF set as Non-PCM\n");
5342
5343 if (u8SpdifMode == SPDIF_OUT_TRANSCODE)
5344 {
5345 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, TRUE, 0);
5346 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, TRUE, 0);
5347 }
5348 else
5349 {
5350 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
5351 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
5352 }
5353
5354 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x02); /* Grp C in */
5355 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG+1, 0x01, 0x00);
5356 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x02); /* Grp C in */
5357 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG+1, 0x01, 0x00);
5358 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
5359 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM;
5360 AUDIO_DELAY1MS(5);
5361 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x02, 0x02); /* Non-PCM */
5362
5363 break;
5364 }
5365
5366 case SPDIF_OUT_PCM:
5367 default:
5368 {
5369 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "HAL SPDIF set as PCM\n");
5370
5371 AUDIO_DELAY1MS(5);
5372 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC1, FALSE, 0);
5373 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_TTS_EN, ADEC2, FALSE, 0);
5374 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x2, 0x0); /* PCM Mode */
5375 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF_OUT_CFG, 0x07, 0x00); /* Tx1 Grp A in */
5376 HAL_AUDIO_WriteMaskByte(REG_AUDIO_SPDIF2_OUT_CFG, 0x07, 0x00); /* Tx2 Grp A in */
5377 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
5378 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM;
5379
5380 break;
5381 }
5382 }
5383
5384 u32bPreDTSCD = u32bDTSCD;
5385 g_u32bDTSCD = u32bDTSCD;
5386 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5387 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5388
5389 g_AudioVars2->g_eSpdifOutputType = u8SpdifMode;
5390 g_AudioVars2->g_PreMainDecodeId = u8MainDecodeId;
5391 g_AudioVars2->g_PreMainDspCodeType = MainDspCodeType;
5392
5393 u32PreHDMITxSamplingRate = u32HDMITxSamplingRate;
5394 u32PreSPDIFTxSamplingRate = u32SPDIFTxSamplingRate;
5395 HAL_AUDIO_Set_DecimationMode(AUDIO_HDMI_ARC_OUTPUT, u8MainDecodeId);
5396 HAL_AUDIO_Set_DecimationMode(AUDIO_SPDIF_OUTPUT, u8MainDecodeId);
5397
5398 _HAL_AUDIO_SPDIF_SetMute(g_AudioVars2->g_SPDIF_MuteStatus);
5399 }
5400
5401 ////////////////////////////////////////////////////////////////////////////////
5402 /// @brief \b Function \b Name: _HAL_AUDIO_SPDIF_GetMode() @@KH
5403 /// @brief \b Function \b Description: This routine is used to get S/PDIF mode.
5404 /// @param <IN> \b NONE :
5405 /// @param <OUT> \b NONE :
5406 /// @param <RET> \b BYTE : Se-DSP REG_M2D_MAILBOX_SPDIF_CTRL value
5407 /// u8Spdif_mode = 0x0 : SPDIF enable, PCM mode
5408 /// u8Spdif_mode = 0x1 : SPDIF OFF
5409 /// u8Spdif_mode = 0x2 : SPDIF enable, non-PCM mode
5410 /// @param <GLOBAL> \b NONE :
5411 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_SPDIF_GetMode(void)5412 MS_U8 _HAL_AUDIO_SPDIF_GetMode(void)
5413 {
5414 return g_AudioVars2->g_eSpdifOutputType;
5415 }
5416
5417 ////////////////////////////////////////////////////////////////////////////////
5418 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetSCMS()
5419 /// @brief \b Function \b Description: This routine is used to set SPDIF SCMS.
5420 /// @param C_bit_en \b : copy right control bit, register in 0x2C80[5]
5421 /// @param L_bit_en \b : generation bit, register in 0x2C82[7]
5422 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en,MS_U8 L_bit_en)5423 void HAL_AUDIO_SPDIF_SetSCMS(MS_U8 C_bit_en, MS_U8 L_bit_en)
5424 {
5425 MS_BOOL retTx1, retTx2;
5426
5427 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
5428 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
5429 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
5430 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5431 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5432
5433 if (retTx1 == TRUE && retTx2 == TRUE)
5434 {
5435 stDigitalChannelStatusTx1.stCopyRight.CBit = C_bit_en;
5436 stDigitalChannelStatusTx1.stCopyRight.LBit = L_bit_en;
5437 stDigitalChannelStatusTx2.stCopyRight.CBit = C_bit_en;
5438 stDigitalChannelStatusTx2.stCopyRight.LBit = L_bit_en;
5439 }
5440 else
5441 {
5442 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
5443 return;
5444 }
5445
5446 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5447 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5448 }
5449
5450 ////////////////////////////////////////////////////////////////////////////////
5451 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_GetSCMS()
5452 /// @brief \b Function \b Description: This routine is used to get SPDIF SCMS.
5453 /// @return MS_U8 \b : SCMS[0] = C bit status, SCMS[1] = L bit status
5454 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_GetSCMS(void)5455 MS_U8 HAL_AUDIO_SPDIF_GetSCMS(void)
5456 {
5457
5458 MS_U8 SCMS_status, SCMS_C_bit_tmp, SCMS_L_bit_tmp;
5459
5460 HALAUDIO_CHECK_SHM_INIT;
5461
5462 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.CBit)
5463 {
5464 SCMS_C_bit_tmp = 0x01;
5465 }
5466 else
5467 {
5468 SCMS_C_bit_tmp = 0x00;
5469 }
5470
5471 if(g_AudioVars2->stDigitalOutChannelStatus[DIGITAL_SPDIF_OUTPUT].stCopyRight.LBit)
5472 {
5473 SCMS_L_bit_tmp = 0x02;
5474 }
5475 else
5476 {
5477 SCMS_L_bit_tmp = 0x00;
5478 }
5479
5480 SCMS_status = SCMS_C_bit_tmp | SCMS_L_bit_tmp;
5481
5482 return(SCMS_status);
5483 }
5484
5485 ////////////////////////////////////////////////////////////////////////////////
5486 /// @brief \b Function \b Name: HAL_AUDIO_SetChannelStatus()
5487 /// @brief \b Function \b Description: This routine is used to set SPdif channel status.
5488 /// @param <IN> \b eType :
5489 /// @param <OUT> \b NONE :
5490 /// @param <RET> \b NONE :
5491 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType,SPDIF_CS_MODE_VALUE eValue)5492 void HAL_AUDIO_SetChannelStatus(SPDIF_CS_MODE_TYPE eType, SPDIF_CS_MODE_VALUE eValue)
5493 {
5494 MS_U8 u8Type;
5495
5496 u8Type=(MS_U8)eType;
5497
5498 MS_BOOL retTx1, retTx2;
5499 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
5500 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
5501 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
5502 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5503 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5504
5505
5506 if (retTx1 == FALSE || retTx2 == FALSE)
5507 {
5508 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
5509 return;
5510 }
5511
5512 switch(u8Type)
5513 {
5514 case SPDIF_CHANNEL_STATUS_FS:
5515 stDigitalChannelStatusTx1.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx1
5516 stDigitalChannelStatusTx2.u8SamplingRate = (MS_U8)eValue; // S/PDIF Tx2
5517 break;
5518 case SPDIF_CHANNEL_STATUS_CATEGORY:
5519 stDigitalChannelStatusTx1.u8Category = (MS_U8)eValue; // Tx1 By-pass L- bit
5520 stDigitalChannelStatusTx2.u8Category = (MS_U8)eValue; // Tx2 By-pass L- bit
5521 break;
5522 case SPDIF_CHANNEL_STATUS_PCM_FORMAT:
5523 stDigitalChannelStatusTx1.u8PcmFormatControl = (MS_U8)eValue; // Tx1 By-pass Copy right bit
5524 stDigitalChannelStatusTx2.u8PcmFormatControl = (MS_U8)eValue; // Tx2 By-pass Copy right bit
5525 break;
5526
5527 default :
5528 break;
5529 }
5530
5531 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5532 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5533 }
5534
5535 ////////////////////////////////////////////////////////////////////////////////
5536 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_ChannelStatus_CTRL()
5537 /// @brief \b Function \b Description: This routine is used to control SPDIF CS in detail.
5538 /// @return MS_U8 \b :
5539 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode,AUDIO_SPDIF_CS_TYPE_STATUS status)5540 MS_BOOL HAL_AUDIO_SPDIF_ChannelStatus_CTRL(AUDIO_SPDIF_CS_TYPE cs_mode, AUDIO_SPDIF_CS_TYPE_STATUS status)
5541 {
5542 MS_BOOL status_rtn = FALSE;
5543 MS_BOOL retTx1, retTx2;
5544
5545 Digital_Out_Channel_Status_t stDigitalChannelStatusTx1, stDigitalChannelStatusTx2;
5546 memset(&stDigitalChannelStatusTx1, 0x00, sizeof(Digital_Out_Channel_Status_t));
5547 memset(&stDigitalChannelStatusTx2, 0x00, sizeof(Digital_Out_Channel_Status_t));
5548 retTx1 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5549 retTx2 = HAL_AUDIO_DigitalOut_GetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5550
5551 if (retTx1 == FALSE || retTx2 == FALSE)
5552 {
5553 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : Failed to get channel status !!!\n", __FUNCTION__);
5554 return status_rtn;
5555 }
5556
5557 switch (cs_mode)
5558 {
5559 case SPDIF_CS_CategoryCode:
5560 switch(status)
5561 {
5562 case SPDIF_CS_Category_BroadCast:
5563 stDigitalChannelStatusTx1.u8Category = 0x20;
5564 stDigitalChannelStatusTx2.u8Category = 0x20;
5565 break;
5566
5567 case SPDIF_CS_Category_General:
5568 stDigitalChannelStatusTx1.u8Category = 0x00;
5569 stDigitalChannelStatusTx2.u8Category = 0x00;
5570 break;
5571
5572 case SPDIF_CS_Category_BroadCast_JP:
5573 stDigitalChannelStatusTx1.u8Category = 0x20;
5574 stDigitalChannelStatusTx2.u8Category = 0x20;
5575 break;
5576
5577 case SPDIF_CS_Category_BroadCast_EU:
5578 stDigitalChannelStatusTx1.u8Category = 0x30;
5579 stDigitalChannelStatusTx2.u8Category = 0x30;
5580 break;
5581
5582 case SPDIF_CS_Category_BroadCast_USA:
5583 stDigitalChannelStatusTx1.u8Category = 0x26;
5584 stDigitalChannelStatusTx2.u8Category = 0x26;
5585 break;
5586
5587 default :
5588 stDigitalChannelStatusTx1.u8Category = 0x00;
5589 stDigitalChannelStatusTx2.u8Category = 0x00;
5590 break;
5591 }
5592 status_rtn = TRUE;
5593 break;
5594
5595 case SPDIF_CS_CopyRight:
5596 if(status == SPDIF_CS_CopyRight_CP)
5597 {
5598 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
5599 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
5600 }
5601 if(status == SPDIF_CS_CopyRight_NonCP)
5602 {
5603 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
5604 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
5605 }
5606 status_rtn = TRUE;
5607 break;
5608
5609 case SPDIF_CS_SourceNumber:
5610 if(status == SPDIF_CS_SourceNumber_2)
5611 {
5612 stDigitalChannelStatusTx1.u8SourceNumber = 0x40;
5613 stDigitalChannelStatusTx2.u8SourceNumber = 0x40;
5614 }
5615 if(status == SPDIF_CS_SourceNumber_5)
5616 {
5617 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
5618 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
5619 }
5620 if(status == SPDIF_CS_SourceNumber_6)
5621 {
5622 stDigitalChannelStatusTx1.u8SourceNumber = 0xA0;
5623 stDigitalChannelStatusTx2.u8SourceNumber = 0xA0;
5624 }
5625 status_rtn = TRUE;
5626 break;
5627
5628 case SPDIF_CS_ChannelNumber:
5629 if(status == SPDIF_CS_ChannelNumber_A_Left)
5630 {
5631 stDigitalChannelStatusTx1.u8ChannelNumber = 0x08;
5632 stDigitalChannelStatusTx2.u8ChannelNumber = 0x08;
5633 }
5634 if(status == SPDIF_CS_ChannelNumber_B_Right)
5635 {
5636 stDigitalChannelStatusTx1.u8ChannelNumber = 0x04;
5637 stDigitalChannelStatusTx2.u8ChannelNumber = 0x04;
5638 }
5639 if(status == SPDIF_CS_ChannelNumber_C)
5640 {
5641 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0C;
5642 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0C;
5643 }
5644 if(status == SPDIF_CS_ChannelNumber_D)
5645 {
5646 stDigitalChannelStatusTx1.u8ChannelNumber = 0x02;
5647 stDigitalChannelStatusTx2.u8ChannelNumber = 0x02;
5648 }
5649 if(status == SPDIF_CS_ChannelNumber_E)
5650 {
5651 stDigitalChannelStatusTx1.u8ChannelNumber = 0x0A;
5652 stDigitalChannelStatusTx2.u8ChannelNumber = 0x0A;
5653 }
5654 if(status == SPDIF_CS_ChannelNumber_F)
5655 {
5656 stDigitalChannelStatusTx1.u8ChannelNumber = 0x06;
5657 stDigitalChannelStatusTx2.u8ChannelNumber = 0x06;
5658 }
5659 status_rtn = TRUE;
5660 break;
5661
5662 case SPDIF_CS_SmpFreq:
5663 switch (status)
5664 {
5665 case SPDIF_CS_SmpFreq_192:
5666 stDigitalChannelStatusTx1.u8SamplingRate = 0x70;
5667 stDigitalChannelStatusTx2.u8SamplingRate = 0x70;
5668 break;
5669
5670 case SPDIF_CS_SmpFreq_96:
5671 stDigitalChannelStatusTx1.u8SamplingRate = 0x50;
5672 stDigitalChannelStatusTx2.u8SamplingRate = 0x50;
5673 break;
5674
5675 case SPDIF_CS_SmpFreq_48:
5676 stDigitalChannelStatusTx1.u8SamplingRate = 0x40;
5677 stDigitalChannelStatusTx2.u8SamplingRate = 0x40;
5678 break;
5679
5680 case SPDIF_CS_SmpFreq_176:
5681 stDigitalChannelStatusTx1.u8SamplingRate = 0x30;
5682 stDigitalChannelStatusTx2.u8SamplingRate = 0x30;
5683 break;
5684
5685 case SPDIF_CS_SmpFreq_88:
5686 stDigitalChannelStatusTx1.u8SamplingRate = 0x10;
5687 stDigitalChannelStatusTx2.u8SamplingRate = 0x10;
5688 break;
5689
5690 case SPDIF_CS_SmpFreq_44:
5691 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
5692 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
5693 break;
5694
5695 case SPDIF_CS_SmpFreq_64:
5696 stDigitalChannelStatusTx1.u8SamplingRate = 0x00;
5697 stDigitalChannelStatusTx2.u8SamplingRate = 0x00;
5698 break;
5699
5700 case SPDIF_CS_SmpFreq_32:
5701 stDigitalChannelStatusTx1.u8SamplingRate = 0xC0;
5702 stDigitalChannelStatusTx2.u8SamplingRate = 0xC0;
5703 break;
5704
5705 default:
5706 status_rtn = FALSE;
5707 break;
5708 }
5709 status_rtn = TRUE;
5710 break;
5711
5712 case SPDIF_CS_ClockAcc:
5713 status_rtn = TRUE;
5714 break;
5715
5716 case SPDIF_ChannelAB:
5717 if (status == SPDIF_ChannelAB_Invalid_ON)
5718 {
5719 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx1 Invalid bit=high in non-PCM mode
5720 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_NONPCM; // Tx2 Invalid bit=high in non-PCM mode
5721 }
5722 if (status == SPDIF_ChannelAB_Invalid_OFF)
5723 {
5724 stDigitalChannelStatusTx1.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx1 Invalid bit=low in PCM mode
5725 stDigitalChannelStatusTx2.u8PcmFormatControl = SPDIF_CS_FORMAT_PCM; // Tx2 Invalid bit=low in PCM mode
5726 }
5727 status_rtn = TRUE;
5728 break;
5729
5730 case SPDIF_CS_CopyProtect:
5731 switch (status)
5732 {
5733 case SPDIF_CS_CopyProtect_CopyFree:
5734 stDigitalChannelStatusTx1.stCopyRight.CBit = 1;
5735 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
5736 stDigitalChannelStatusTx2.stCopyRight.CBit = 1;
5737 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
5738 status_rtn = TRUE;
5739 break;
5740
5741 case SPDIF_CS_CopyProtect_CopyOnce:
5742 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
5743 stDigitalChannelStatusTx1.stCopyRight.LBit = 0;
5744 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
5745 stDigitalChannelStatusTx2.stCopyRight.LBit = 0;
5746 status_rtn = TRUE;
5747 break;
5748
5749 case SPDIF_CS_CopyProtect_CopyNever:
5750 stDigitalChannelStatusTx1.stCopyRight.CBit = 0;
5751 stDigitalChannelStatusTx1.stCopyRight.LBit = 1;
5752 stDigitalChannelStatusTx2.stCopyRight.CBit = 0;
5753 stDigitalChannelStatusTx2.stCopyRight.LBit = 1;
5754 status_rtn = TRUE;
5755 break;
5756
5757 default:
5758 status_rtn = FALSE;
5759 break;
5760 }
5761 break;
5762
5763 default:
5764 status_rtn = FALSE;
5765 break;
5766
5767 }
5768
5769 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_SPDIF_OUTPUT, &stDigitalChannelStatusTx1);
5770 HAL_AUDIO_DigitalOut_SetChannelStatus(DIGITAL_HDMI_ARC_OUTPUT, &stDigitalChannelStatusTx2);
5771
5772 return(status_rtn);
5773 }
5774
5775 ////////////////////////////////////////////////////////////////////////////////
5776 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_Monitor_SamplingRate()
5777 /// @brief \b Function \b Description: This routine is to set ADC clock for SPDIF raw out
5778 /// @param <IN> \b NONE :
5779 /// @param <OUT> \b NONE :
5780 /// @param <RET> \b NONE :
5781 /// @param <GLOBAL> \b NONE :
5782 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)5783 void HAL_AUDIO_SPDIF_Monitor_SamplingRate(void)
5784 {
5785 return;
5786 }
5787
5788 ////////////////////////////////////////////////////////////////////////////////
5789 /// @brief \b Function \b Name: HAL_AUDIO_SPDIF_SetOutputType()
5790 /// @brief \b Function \b Description: This routine is used to set S/PDIF output mode
5791 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource,AUDIO_SPDIF_OUTPUT_TYPE eType)5792 void HAL_AUDIO_SPDIF_SetOutputType(AUDIO_SOURCE_INFO_TYPE eSource, AUDIO_SPDIF_OUTPUT_TYPE eType)
5793 {
5794 eSource=eSource;
5795 eType=eType;
5796 }
5797
5798 ///-----------------------------------------------------------------------------
5799 ////////////////////////////////////////////////////////////////////////////////
5800 ////////////////////////////////////////////////////////////////////////////////
5801 ///
5802 /// AUDIO HDMI Relational Hal Function
5803 ///
5804 ////////////////////////////////////////////////////////////////////////////////
5805 ////////////////////////////////////////////////////////////////////////////////
5806 ///-----------------------------------------------------------------------------
5807 ////////////////////////////////////////////////////////////////////////////////
5808 /// @brief \b Function \b Name: _HAL_AUDIO_HDMI_Tx_SetMute()
5809 /// @brief \b Function \b Description: This routine is used to mute HDMI Tx output(by DSP)
5810 /// @param <IN> \b bEnMute : 0--Disable mute
5811 /// 1--Enable mute
5812 /// @param <OUT> \b NONE :
5813 /// @param <RET> \b NONE :
5814 /// @param <GLOBAL> \b NONE :
5815 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)5816 void _HAL_AUDIO_HDMI_Tx_SetMute(MS_BOOL bEnMute)
5817 {
5818 return;
5819 }
5820
5821 ////////////////////////////////////////////////////////////////////////////////
5822 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor()
5823 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status
5824 /// @param <IN> \b NONE :
5825 /// @param <OUT> \b NONE :
5826 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
5827 /// @param <GLOBAL> \b NONE :
5828 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor(void)5829 MS_BOOL HAL_AUDIO_HDMI_NonpcmMonitor(void)
5830 {
5831 MS_BOOL bHdmiNonPcmMode = FALSE;
5832 MS_U8 u8TargetPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
5833 MS_U8 u8CurrentPcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
5834
5835 HAL_AUDIO_AbsWriteMaskByte(0x1027C8, 0x02, 0x02); // Add audio bank offset
5836 if (((HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_INPUT) & 0xC0) == 0x40) || (HAL_AUDIO_HDMI_NonpcmMonitor2() == 0x1))
5837 {
5838 u8TargetPcmRenderControl = 0; //decoder mode
5839 bHdmiNonPcmMode = TRUE;
5840 }
5841 else
5842 {
5843 u8TargetPcmRenderControl = 2; //stereo mode
5844 bHdmiNonPcmMode = FALSE;
5845 }
5846
5847 /* if current main input source is HDMI, then configure R2's PCM Render */
5848 if (g_AudioVars2->eAudioSource == E_AUDIO_INFO_HDMI_IN)
5849 {
5850 u8CurrentPcmRenderControl = (HAL_AUR2_ReadByte(REG_SNDR2_MBOX_BYTE_DAP_SEL) & 0x06) >> 1;
5851 if (u8TargetPcmRenderControl != u8CurrentPcmRenderControl)
5852 {
5853 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8TargetPcmRenderControl << 1));
5854 }
5855 }
5856
5857 return bHdmiNonPcmMode;
5858 }
5859
5860 ////////////////////////////////////////////////////////////////////////////////
5861 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_NonpcmMonitor2()
5862 /// @brief \b Function \b Description: Report PCM/HDMI non-PCM status from DSP
5863 /// @param <IN> \b NONE :
5864 /// @param <OUT> \b NONE :
5865 /// @param <RET> \b MS_U8 : return HDMI PCM/non-PCM status
5866 /// @param <GLOBAL> \b NONE :
5867 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_NonpcmMonitor2(void)5868 MS_U8 HAL_AUDIO_HDMI_NonpcmMonitor2(void)
5869 {
5870 MS_U32 HDMI_lock_status_tmp;
5871 HDMI_lock_status_tmp = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_hdmi_npcm_lock, DSP_MEM_TYPE_DM);
5872 if ((HDMI_lock_status_tmp&0x30) == 0x30)
5873 {
5874 return (1);
5875 }
5876 else
5877 {
5878 return (0);
5879 }
5880 }
5881
5882 ////////////////////////////////////////////////////////////////////////////////
5883 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_DolbyMonitor() @@Need_Modify
5884 /// @brief \b Function \b Description: Report HDMI non-PCM Dolby mod status
5885 /// @param <IN> \b NONE :
5886 /// @param <OUT> \b NONE :
5887 /// @param <RET> \b u8DolbyModeType :
5888 /// 0-- Other mode
5889 /// 1-- Dolby mode
5890 /// @param <GLOBAL> \b NONE :
5891 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_DolbyMonitor(void)5892 MS_U8 HAL_AUDIO_HDMI_DolbyMonitor(void)
5893 {
5894 return HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_HDMI_PC);
5895 }
5896
5897 ////////////////////////////////////////////////////////////////////////////////
5898 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_SetNonpcm() @@Need_Modify
5899 /// @brief \b Function \b Description: Set HDMI PCM/non-PCM Mode
5900 /// @param <IN> \b nonPCM_en :
5901 /// -- 0: PCM mode
5902 /// -- 1: non-PCM mode
5903 /// @param <OUT> \b NONE :
5904 /// @param <RET> \b NONE :
5905 /// @param <GLOBAL> \b NONE :
5906 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)5907 void HAL_AUDIO_HDMI_SetNonpcm(MS_U8 nonPCM_en)
5908 {
5909 //=======================================================
5910 Hdmi_Input_Path HDMI_INPUT_PATH ;
5911 MS_BOOL bIsNonPCM= FALSE;
5912 MS_U8 u8DecoderType = 0;
5913
5914 bIsNonPCM = (MS_BOOL)(nonPCM_en & HDMI_NonPCM_Mask); // Use bit 1 mask check PCM/nonPCM
5915 HDMI_INPUT_PATH = (Hdmi_Input_Path)(nonPCM_en & HDMI_Input_Path_Mask); // Use bit2 mask check main or sub in PIP
5916
5917 if (bIsNonPCM) //====== HDMI nonpcm mode =======
5918 {
5919 u8DecoderType = HAL_AUDIO_HDMI_DolbyMonitor();
5920
5921 switch(u8DecoderType)
5922 {
5923 case AU_HDMI_DTS_TYPE1:
5924 case AU_HDMI_DTS_TYPE2:
5925 case AU_HDMI_DTS_TYPE3:
5926 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5927 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_DTS);
5928 else
5929 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_DTS);
5930
5931 break;
5932 case AU_HDMI_AC3:
5933 case AU_HDMI_AC3P:
5934 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5935 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB2_AC3);
5936 else
5937 HAL_AUDIO_SetSystem( MSAPI_AUD_DVB_AC3);
5938
5939 break;
5940 };
5941
5942 // Audio Input path config
5943 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
5944 {
5945 // HDMI in 2nd Decoder
5946 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5947 {
5948 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_6);
5949 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5950 }
5951 else
5952 {
5953 HAL_AUDIO_SetInputPath(AUDIO_DSP3_HDMI_INPUT, AUDIO_PATH_MAIN);
5954 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5955 }
5956 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP); // Stop
5957 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER3_CFG,0x07,0x04);
5958 MsOS_DelayTask(10);
5959 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_PLAY); // PlaY
5960 }
5961 else // HDMI in 1st Decoder
5962 {
5963 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5964 {
5965 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_6);
5966 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x11);
5967 }
5968 else
5969 {
5970 HAL_AUDIO_SetInputPath(AUDIO_DSP1_HDMI_INPUT, AUDIO_PATH_MAIN);
5971 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x11);
5972 }
5973
5974 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP); // Stop
5975 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04);
5976 MsOS_DelayTask(10);
5977 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_PLAY); // Play
5978 }
5979
5980 //========= Set for S/PDIF out ===========
5981 HAL_AUDIO_SPDIF_SetMode(_HAL_AUDIO_SPDIF_GetMode(), E_AUDIO_INFO_HDMI_IN);
5982
5983 //Byte swap setting
5984 if (HAL_AUDIO_HDMI_DolbyMonitor() == AU_HDMI_AC3P)
5985 {
5986 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 1, 0);
5987 }
5988 else
5989 {
5990 HAL_MAD_SetAC3PInfo(Audio_AC3P_infoType_BYTESWAP, 0, 0);
5991 }
5992 }
5993 else //====== HDMI pcm mode =======
5994 {
5995 if(HDMI_INPUT_PATH == Hdmi_Input_Sub) //sub
5996 {
5997 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_6);
5998 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_6,0x19);
5999 }
6000 else
6001 {
6002 HAL_AUDIO_SetInputPath(AUDIO_HDMI_INPUT, AUDIO_PATH_MAIN);
6003 HAL_AUDIO_HDMIAutoMute(AUDIO_PATH_MAIN,0x19);
6004 }
6005
6006 HAL_AUDIO_SPDIF_SetMode(SPDIF_OUT_PCM, E_AUDIO_INFO_HDMI_IN);
6007
6008 if (HAL_MAD_GetAC3PInfo(Audio_AC3P_infoType_hdmiAC3inSE) == 1)
6009 {
6010 HAL_AUR2_WriteByte(REG_R2_DECODE2_CMD, AU_DEC_R2_CMD_STOP);
6011 }
6012 else
6013 {
6014 HAL_AUR2_WriteByte(REG_R2_DECODE1_CMD, AU_DEC_R2_CMD_STOP);
6015 }
6016 }
6017
6018 }
6019
6020 ////////////////////////////////////////////////////////////////////////////////
6021 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_AC3_PathCFG() @@Need_Modify
6022 /// @brief \b Function \b Description: Set DVB/HDMI AC3 path Control
6023 /// @param <IN> \b u8Ctrl :
6024 /// -- 0: DVB2_AD path
6025 /// -- 1: HDMI path
6026 /// @param <OUT> \b NONE :
6027 /// @param <RET> \b NONE :
6028 /// @param <GLOBAL> \b NONE :
6029 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)6030 void HAL_AUDIO_HDMI_AC3_PathCFG(MS_U8 u8Ctrl)
6031 {
6032 if (u8Ctrl == 1)
6033 { // HDMI
6034 /* use CH1 decode HDMI AC3 */
6035 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x04); // HDMI_AC3 REG CFG
6036 }
6037 else
6038 { // DTV
6039 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECODER1_CFG,0x07,0x00); // DVB1 REG CFG
6040 }
6041 }
6042
6043
6044 ////////////////////////////////////////////////////////////////////////////////
6045 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Get_SYNTH_FREQ() @@Need_Modify
6046 /// @brief \b Function \b Description: Audio HDMI CTS-N synthesizer input signal detect.
6047 /// @param <IN> \b NONE :
6048 /// @param <OUT> \b MS_U16 : return freq. If no signal, return 0
6049 /// @param <RET> \b NONE :
6050 /// @param <GLOBAL> \b NONE :
6051 ////////////////////////////////////////////////////////////////////////////////
6052
HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)6053 MS_U16 HAL_AUDIO_HDMI_Get_SYNTH_FREQ(void)
6054 {
6055 MS_U16 freq;
6056
6057 freq = HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH) + 0x100 * HAL_AUDIO_ReadByte(REG_AUDIO_STATUS_SYNTH+1);
6058
6059 if(freq & 0x8000)
6060 return 0; //no signal
6061
6062 return freq;
6063 }
6064
6065 ////////////////////////////////////////////////////////////////////////////////
6066 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Set_DwonSample() @@Cathy
6067 /// @brief \b Function \b Description: set HDMI downsample rate
6068 /// @param <IN> \b MS_U8 : donwsample ratio ; no need in T3
6069 /// @param <OUT> \b NONE :
6070 /// @param <RET> \b NONE :
6071 /// @param <GLOBAL> \b NONE :
6072 ////////////////////////////////////////////////////////////////////////////////
6073
HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)6074 void HAL_AUDIO_HDMI_Set_DwonSample(MS_U8 ratio)
6075 {
6076 ratio=ratio; // No need in T3
6077 }
6078
6079
6080 ////////////////////////////////////////////////////////////////////////////////
6081 /// @brief \b Function \b Name: HAL_AUDIO_HDMIAutoMute() @@Need_Modify
6082 /// @brief \b Function \b This routine sets the automute function of HDMI.
6083 /// @param <IN> \b MS_U8 : ch : 0~5
6084 /// value: register value
6085 /// @param <OUT> \b NONE :
6086 /// @param <RET> \b NONE :
6087 /// @param <GLOBAL> \b NONE :
6088 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMIAutoMute(MS_U8 ch,MS_U8 value)6089 void HAL_AUDIO_HDMIAutoMute(MS_U8 ch, MS_U8 value)
6090 {
6091 if(ch < 4)
6092 {
6093 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+(ch<<1),value);
6094 }
6095 else if(ch == 4)
6096 {
6097 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL1+1,value);
6098 }
6099 else if(ch == 5)
6100 {
6101 HAL_AUDIO_WriteByte(REG_AUDIO_MUTE_CTRL2+1,value);
6102 }
6103 }
6104
6105 ////////////////////////////////////////////////////////////////////////////////
6106 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_Tx_GetStatus()
6107 /// @brief \b Function \b Description: This routine is used to get HDMI Tx status
6108 /// @param onOff \b : HDMI tx function is availible in this chip ?
6109 /// @param hdmi_SmpFreq \b : Audio current sample freq for tx
6110 /// @param outType \b : PCM mode or nonPCM mode
6111 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL * onOff,AUDIO_FS_TYPE * hdmi_SmpFreq,HDMI_TX_OUTPUT_TYPE * outType)6112 void HAL_AUDIO_HDMI_Tx_GetStatus(MS_BOOL *onOff, AUDIO_FS_TYPE *hdmi_SmpFreq, HDMI_TX_OUTPUT_TYPE *outType )
6113 {
6114 *onOff = FALSE;
6115 *hdmi_SmpFreq = AUDIO_FS_UNSUPPORT;
6116 *outType = HDMI_OUT_PCM;
6117 }
6118
6119
6120
6121 ///-----------------------------------------------------------------------------
6122 ////////////////////////////////////////////////////////////////////////////////
6123 ////////////////////////////////////////////////////////////////////////////////
6124 ///
6125 /// AUDIO Internel Use Hal Function
6126 ///
6127 ////////////////////////////////////////////////////////////////////////////////
6128 ////////////////////////////////////////////////////////////////////////////////
6129 ///-----------------------------------------------------------------------------
6130
6131 ////////////////////////////////////////////////////////////////////////////////
6132 /// @brief \b Function \b Name: _HAL_AUDIO_InitStep1() @@Need_Modify
6133 /// @brief \b Function \b Description: This routine is the initialization for Audio module(Step1).
6134 /// @param <IN> \b NONE :
6135 /// @param <OUT> \b NONE :
6136 /// @param <RET> \b NONE :
6137 /// @param <GLOBAL> \b NONE :
6138 ////////////////////////////////////////////////////////////////////////////////
_HAL_AUDIO_InitStep1(void)6139 void _HAL_AUDIO_InitStep1(void)
6140 {
6141 HAL_AUDIO_WriteInitTable();
6142 HAL_AUDIO_SetPowerOn(1);
6143
6144 HAL_AUDIO_SwResetMAD();
6145
6146 // Cathy need remove
6147 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0002);
6148 AUDIO_DELAY1MS(2);
6149 HAL_AUDIO_WriteByte(REG_DEC_IDMA_CTRL0, 0x0003);
6150
6151 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0002);
6152 AUDIO_DELAY1MS(2);
6153 HAL_AUDIO_WriteByte(REG_SE_IDMA_CTRL0, 0x0003);
6154 // Reset Audio MIU Request for DEC-DSP
6155 HAL_MAD_DisEn_MIUREQ();
6156
6157 }
6158
6159
6160 ////////////////////////////////////////////////////////////////////////////////
6161 /// @brief \b Function \b Name: HAL_AUDIO_SetDspBaseAddr()
6162 /// @brief \b Function \b Description: This function is used to set bin file base address in flash for Audio module.
6163 /// @param <IN> \b u8Index :
6164 /// @param <IN> \b Bin_Base_Address :
6165 /// @param <IN> \b Mad_Base_Buffer_Adr :
6166 /// @param <OUT> \b NONE :
6167 /// @param <RET> \b NONE :
6168 /// @param <GLOBAL> \b NONE :
6169 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index,MS_PHY phyBin_Base_Address,MS_PHY phyMad_Base_Buffer_Adr)6170 void HAL_AUDIO_SetDspBaseAddr(MS_U8 u8Index, MS_PHY phyBin_Base_Address, MS_PHY phyMad_Base_Buffer_Adr)
6171 {
6172 HALAUDIO_CHECK_SHM_INIT;
6173
6174 g_AudioVars2->g_DSPMadMIUBank[u8Index] = (MS_U8) (phyMad_Base_Buffer_Adr & 0x0000000F);
6175 phyMad_Base_Buffer_Adr &= 0xFFFFFFF0;
6176 switch(u8Index)
6177 {
6178 case(DSP_ADV): //DSP_ADV=R2=2
6179 g_AudioVars2->g_DSPBinBaseAddress[u8Index] = phyBin_Base_Address; //R2 ADDR setting
6180 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index] = phyMad_Base_Buffer_Adr;
6181 g_DSPMadMIUBank[u8Index] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
6182 g_DSPBinBaseAddress[u8Index] = g_AudioVars2->g_DSPBinBaseAddress[u8Index];
6183 g_DSPMadBaseBufferAdr[u8Index] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
6184
6185 g_AudioVars2->g_DSPBinBaseAddress[u8Index-1] = phyBin_Base_Address; //SE ADEC ADDR setting
6186 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1] = phyMad_Base_Buffer_Adr + (ADEC__R2_DDR_SIZE + ASND__R2_DDR_SIZE);
6187 g_DSPMadMIUBank[u8Index-1] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
6188 g_DSPBinBaseAddress[u8Index-1] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-1];
6189 g_DSPMadBaseBufferAdr[u8Index-1] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-1];
6190
6191 g_AudioVars2->g_DSPBinBaseAddress[u8Index-2] = phyBin_Base_Address; //Comm ADDR setting
6192 g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2] = g_DSPMadBaseBufferAdr[u8Index-1] + ASND_DSP_DDR_SIZE;
6193 g_DSPMadMIUBank[u8Index-2] = g_AudioVars2->g_DSPMadMIUBank[u8Index];
6194 g_DSPBinBaseAddress[u8Index-2] = g_AudioVars2->g_DSPBinBaseAddress[u8Index-2];
6195 g_DSPMadBaseBufferAdr[u8Index-2] = g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index-2];
6196 break;
6197 default:
6198 u8Index = u8Index;
6199 break;
6200 }
6201 #ifndef MSOS_TYPE_NUTTX
6202 AUDIO_TEE_INFO_SHM_CHECK_NULL;
6203 REE_TO_TEE_MBX_MSG_SET_PARAM(0, u8Index);
6204 REE_TO_TEE_MBX_MSG_SET_PARAM(1, (MS_U8)(phyBin_Base_Address&0xFF));
6205 REE_TO_TEE_MBX_MSG_SET_PARAM(2, (MS_U8)((phyBin_Base_Address>>8)&0xFF));
6206 REE_TO_TEE_MBX_MSG_SET_PARAM(3, (MS_U8)((phyBin_Base_Address>>16)&0xFF));
6207 REE_TO_TEE_MBX_MSG_SET_PARAM(4, (MS_U8)((phyBin_Base_Address>>24)&0xFF));
6208 REE_TO_TEE_MBX_MSG_SET_PARAM(5, (MS_U8)(phyMad_Base_Buffer_Adr&0xFF));
6209 REE_TO_TEE_MBX_MSG_SET_PARAM(6, (MS_U8)((phyMad_Base_Buffer_Adr>>8)&0xFF));
6210 REE_TO_TEE_MBX_MSG_SET_PARAM(7, (MS_U8)((phyMad_Base_Buffer_Adr>>16)&0xFF));
6211 REE_TO_TEE_MBX_MSG_SET_PARAM(8, (MS_U8)((phyMad_Base_Buffer_Adr>>24)&0xFF));
6212 REE_TO_TEE_MBX_MSG_SET_PARAM_COUNT(9);
6213 HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr | REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
6214 #endif
6215 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%d DSPBinBaseAddress = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPBinBaseAddress[u8Index]);
6216 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%d DSPMadBaseBufferAdr = 0x%08X\n", u8Index, (unsigned int) g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index]);
6217 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%d DSPMadMIUBank = %d\n", u8Index, g_AudioVars2->g_DSPMadMIUBank[u8Index]);
6218 }
6219
6220 ////////////////////////////////////////////////////////////////////////////////
6221 /// @brief \b Function \b Name: HAL_AUDIO_GetDspMadBaseAddr()
6222 /// @brief \b Function \b Description: This function is used to get the MAD base address.
6223 /// @param <IN> \b u8Index :
6224 /// @param <OUT> \b NONE :
6225 /// @param <RET> \b MS_U32: return the MAD base address
6226 /// @param <GLOBAL> \b NONE :
6227 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)6228 MS_PHY HAL_AUDIO_GetDspMadBaseAddr(MS_U8 u8Index)
6229 {
6230 HALAUDIO_CHECK_SHM_INIT;
6231
6232 if (u8Index == DSP_DEC) // MM case
6233 {
6234 return g_AudioVars2->g_DSPMadBaseBufferAdr[DSP_SE];
6235 }
6236 return g_AudioVars2->g_DSPMadBaseBufferAdr[u8Index];
6237 }
6238
6239 ////////////////////////////////////////////////////////////////////////////////
6240 /// @brief \b Function \b Name: HAL_AUDIO_GetDspBinBaseAddr()
6241 /// @brief \b Function \b Description: This function is used to get the Bin file base address.
6242 /// @param <IN> \b u8Index :
6243 /// @param <OUT> \b NONE :
6244 /// @param <RET> \b MS_U32: return the Bin file base address
6245 /// @param <GLOBAL> \b NONE :
6246 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)6247 MS_PHY HAL_AUDIO_GetDspBinBaseAddr(MS_U8 u8Index)
6248 {
6249 HALAUDIO_CHECK_SHM_INIT;
6250
6251 return g_AudioVars2->g_DSPBinBaseAddress[u8Index];
6252 }
6253
6254 ////////////////////////////////////////////////////////////////////////////////
6255 /// @brief \b Function \b Name: HAL_AUDIO_SetDspCodeType()
6256 /// @brief \b Function \b Description: This function is used to set the DSP code type.
6257 /// @param <IN> \b NONE :
6258 /// @param <OUT> \b NONE :
6259 /// @param <RET> \b MS_U8: DSP code type.
6260 /// @param <GLOBAL> \b NONE :
6261 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)6262 void HAL_AUDIO_SetDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
6263 {
6264 HALAUDIO_CHECK_SHM_INIT;
6265
6266 if(bFlag == FALSE)
6267 {
6268 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " [Audio] DSP1 Load code fail !!! SetDspCodeType Fail !!! \r\n");
6269 return;
6270 }
6271
6272 g_AudioVars2->g_DspCodeType = dspCodeType;
6273 }
6274
6275 ////////////////////////////////////////////////////////////////////////////////
6276 /// @brief \b Function \b Name: HAL_AUDIO_GetDspCodeType()
6277 /// @brief \b Function \b Description: This function is used to get the MAD base address.
6278 /// @param <IN> \b NONE :
6279 /// @param <OUT> \b NONE :
6280 /// @param <RET> \b MS_U8: DSP code type.
6281 /// @param <GLOBAL> \b NONE :
6282 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDspCodeType(void)6283 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDspCodeType(void)
6284 {
6285 HALAUDIO_CHECK_SHM_INIT;
6286
6287 return g_AudioVars2->g_DspCodeType;
6288 }
6289
6290
6291 ////////////////////////////////////////////////////////////////////////////////
6292 /// @brief \b Function \b Name: HAL_AUDIO_SetDsp2CodeType() @@Cathy
6293 /// @brief \b Function \b Description: This function is used to set the DSP2 code type.
6294 /// @param <IN> \b NONE :
6295 /// @param <OUT> \b NONE :
6296 /// @param <RET> \b MS_U8: DSP code type.
6297 /// @param <GLOBAL> \b NONE :
6298 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)6299 void HAL_AUDIO_SetDsp2CodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
6300 {
6301 HALAUDIO_CHECK_SHM_INIT;
6302
6303 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
6304 {
6305 return;
6306 }
6307
6308 if(bFlag == FALSE)
6309 {
6310 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " [Audio] DSP2 Load code fail !!! SetDsp2CodeType Fail !!! \r\n");
6311 return;
6312 }
6313 g_AudioVars2->g_Dsp2CodeType = dspCodeType;
6314 }
6315
6316 ////////////////////////////////////////////////////////////////////////////////
6317 /// @brief \b Function \b Name: HAL_AUDIO_GetDsp2CodeType() @@Cathy
6318 /// @brief \b Function \b Description: This function is used to get the MAD base address.
6319 /// @param <IN> \b NONE :
6320 /// @param <OUT> \b NONE :
6321 /// @param <RET> \b MS_U8: DSP code type.
6322 /// @param <GLOBAL> \b NONE :
6323 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDsp2CodeType(void)6324 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetDsp2CodeType(void)
6325 {
6326 HALAUDIO_CHECK_SHM_INIT;
6327
6328 return g_AudioVars2->g_Dsp2CodeType;
6329 }
6330
6331 ////////////////////////////////////////////////////////////////////////////////
6332 /// @brief \b Function \b Name: HAL_AUDIO_GetDSPalive()
6333 /// @brief \b Function \b Description: This function is used to check if DSP alive.
6334 /// @param <IN> \b NONE :
6335 /// @param <OUT> \b NONE :
6336 /// @param <RET> \b MS_U8: DSP alive status.
6337 /// @param <GLOBAL> \b NONE :
6338 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDSPalive(void)6339 MS_U8 HAL_AUDIO_GetDSPalive(void)
6340 {
6341 HALAUDIO_CHECK_SHM_INIT;
6342
6343 return g_AudioVars2->g_u8DspAliveFlag;
6344 }
6345
6346 ////////////////////////////////////////////////////////////////////////////////
6347 /// @brief \b Function \b Name: HAL_AUDIO_SetDSPalive()
6348 /// @brief \b Function \b Description: This function is used to set flag after DSP alive.
6349 /// @param <IN> \b NONE :
6350 /// @param <OUT> \b NONE :
6351 /// @param <RET> \b NONE :
6352 /// @param <GLOBAL> \b NONE :
6353 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDSPalive(MS_U8 alive)6354 void HAL_AUDIO_SetDSPalive(MS_U8 alive)
6355 {
6356 HALAUDIO_CHECK_SHM_INIT;
6357
6358 g_AudioVars2->g_u8DspAliveFlag = alive;
6359 }
6360
6361 ////////////////////////////////////////////////////////////////////////////////
6362 /// @brief \b Function \b Name: HAL_AUDIO_SetAdvSndEffDspCodeType() @@Cathy
6363 /// @brief \b Function \b Description: This function is used to set the DSP AdvSndEff code type.
6364 /// @param <IN> \b NONE :
6365 /// @param <OUT> \b NONE :
6366 /// @param <RET> \b MS_U8: DSP code type.
6367 /// @param <GLOBAL> \b NONE :
6368 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType,MS_BOOL bFlag)6369 void HAL_AUDIO_SetAdvSndEffDspCodeType(AUDIO_DSP_CODE_TYPE dspCodeType, MS_BOOL bFlag)
6370 {
6371 HALAUDIO_CHECK_SHM_INIT;
6372
6373 if (bFlag == FALSE)
6374 {
6375 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " [Audio] ADV_DSP Load code fail !!! SetAdvSndEffDspCodeType Fail !!! \r\n");
6376 return;
6377 }
6378
6379 g_AudioVars2->g_AdvSndEffDspCodeType = dspCodeType;
6380 }
6381
6382 ////////////////////////////////////////////////////////////////////////////////
6383 /// @brief \b Function \b Name: HAL_AUDIO_GetAdvSndEffDspCodeType() @@Cathy
6384 /// @brief \b Function \b Description: This function is used to get the DSP AdvSndEff code type.
6385 /// @param <IN> \b NONE :
6386 /// @param <OUT> \b NONE :
6387 /// @param <RET> \b MS_U8: DSP code type.
6388 /// @param <GLOBAL> \b NONE :
6389 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetAdvSndEffDspCodeType(void)6390 AUDIO_DSP_CODE_TYPE HAL_AUDIO_GetAdvSndEffDspCodeType(void)
6391 {
6392 HALAUDIO_CHECK_SHM_INIT;
6393
6394 return g_AudioVars2->g_AdvSndEffDspCodeType;
6395 }
6396
6397 ////////////////////////////////////////////////////////////////////////////////
6398 /// @brief \b Function \b Name: HAL_AUDIO_BackupMailbox() @@Need_Modify
6399 /// @brief \b Function \b Description: This function is used to backup SIF mailbox.
6400 /// @param <IN> \b NONE :
6401 /// @param <OUT> \b NONE :
6402 /// @param <RET> \b NONE :
6403 /// @param <GLOBAL> \b NONE :
6404 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_BackupMailbox(void)6405 void HAL_AUDIO_BackupMailbox(void)
6406 {
6407 HAL_SIF_BackupMailbox();
6408
6409 MAD2DecCMD = HAL_MAD2_GetDecCmd();
6410 MADDec1CMD = HAL_MAD_GetDecCmd(DVB_Audio_Decoder1);
6411 MADDec2CMD = HAL_MAD_GetDecCmd(DVB_Audio_Decoder2);
6412 MADDec1Type = HAL_AUDIO_AbsReadByte(REG_R2_DECODE1_TYPE) & adec_type_regmask;
6413 MADDec2Type = HAL_AUDIO_AbsReadByte(REG_R2_DECODE2_TYPE) & adec_type_regmask;
6414
6415 HAL_MAD2_SetDecCmd(0x100); // CathyNeedRefine
6416 HAL_MAD_SetDecCmd(AU_DVB_DECCMD_STOP);
6417 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP);
6418
6419 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE1_TYPE, (MS_U8)adec_type_regmask, (MS_U8)adec_type_dummy);
6420 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE2_TYPE, (MS_U8)adec_type_regmask, (MS_U8)adec_type_dummy);
6421 }
6422
6423 ////////////////////////////////////////////////////////////////////////////////
6424 /// @brief \b Function \b Name: HAL_AUDIO_RestoreMailbox() @@Need_Modify
6425 /// @brief \b Function \b Description: This function is used to restore SIF mailbox.
6426 /// @param <IN> \b NONE :
6427 /// @param <OUT> \b NONE :
6428 /// @param <RET> \b NONE :
6429 /// @param <GLOBAL> \b NONE :
6430 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RestoreMailbox(void)6431 void HAL_AUDIO_RestoreMailbox(void)
6432 {
6433 HAL_SIF_RestoreMailbox();
6434 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0xFF); // Toggle 2BCE to update N.F value
6435 HAL_AUDIO_WriteMaskByte(0x2BCE, 0xFF, 0x00);
6436
6437 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE1_TYPE, (MS_U8)adec_type_regmask, (MS_U8)MADDec1Type);
6438 HAL_AUDIO_AbsWriteMaskByte((MS_U32)REG_R2_DECODE2_TYPE, (MS_U8)adec_type_regmask, (MS_U8)MADDec2Type);
6439
6440 HAL_MAD_SetDecCmd(MADDec1CMD);
6441 HAL_MAD_SetDSP2DecCmd(MADDec2CMD);
6442 HAL_MAD2_SetDecCmd(((MS_U16)MAD2DecCMD)+0x100);
6443 }
6444
6445
6446 ////////////////////////////////////////////////////////////////////////////////
6447 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
6448 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
6449 /// @param <IN> \b eType : sampleRate of PCM
6450 /// @param <OUT> \b NONE :
6451 /// @param <RET> \b NONE :
6452 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)6453 void HAL_AUDIO_DmaReader_Init(SAMPLE_RATE sampleRate)
6454 {
6455 MS_U32 audio_pcm_dmaRdr_bufSz = HW_DMA_RDR1_BUF_SIZE;
6456 MS_PHY audio_pcm_dmaRdr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
6457 MS_U16 synthrate, divisor;
6458 MS_U8 tmp1, tmp2, tmp3, tmp4;
6459 MS_U32 i;
6460
6461 /* init DMA writer address */
6462 dmaReader_writePtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
6463 dmaReader_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base);
6464 dmaReader_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaRdr_base + audio_pcm_dmaRdr_bufSz);
6465
6466 /* New DMA Reader setting
6467 * Formula is :
6468 * Synthesizer Rate = 216MHz / Divisor(1, 2, 4 or 8) * 1024 / 256 / Sampling Rate(32Khz, 44.1KHz or 48KHz)
6469 */
6470 switch(sampleRate)
6471 {
6472 case SAMPLE_RATE_96000:
6473 divisor = 0;
6474 synthrate = 0x2328;
6475 break;
6476 case SAMPLE_RATE_44100:
6477 divisor = 0;
6478 synthrate = 0x4C87;
6479 break;
6480 case SAMPLE_RATE_32000:
6481 divisor = 0;
6482 synthrate = 0x6978;
6483 break;
6484 case SAMPLE_RATE_48000:
6485 divisor = 0;
6486 synthrate = 0x4650;
6487 break;
6488 case SAMPLE_RATE_22050:
6489 divisor = 1;
6490 synthrate = 0x4C87;
6491 break;
6492 case SAMPLE_RATE_16000:
6493 divisor = 1;
6494 synthrate = 0x6978;
6495 break;
6496 case SAMPLE_RATE_24000:
6497 divisor = 1;
6498 synthrate = 0x4650;
6499 break;
6500 case SAMPLE_RATE_11025:
6501 divisor = 2;
6502 synthrate = 0x4C87;
6503 break;
6504 case SAMPLE_RATE_8000:
6505 divisor = 2;
6506 synthrate = 0x6978;
6507 break;
6508 case SAMPLE_RATE_12000:
6509 divisor = 2;
6510 synthrate = 0x4650;
6511 break;
6512 default:
6513 divisor = 0;
6514 synthrate = 0x4650;
6515 break;
6516 }
6517
6518 /* Initial DMA Reader path & clk select */ //DMA reader -> CH8
6519 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04); //SEL_CLK_DMA_READER
6520 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F ); //CH8 sel to DMA Rdr
6521
6522 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //reset dma reader
6523
6524 HAL_AUDIO_WriteMaskByte(0x2B8E, 0xFF, ((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE) & 0xFF)); //DMA Reader Base Addr[7:0]
6525 HAL_AUDIO_WriteMaskReg(0x2B84, 0xFFFF,(((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>8) & 0xFFFF)); //DMA Reader Base Addr[23:8]
6526 HAL_AUDIO_WriteMaskByte(0x2B8F, 0x0F, (((audio_pcm_dmaRdr_base/BYTES_IN_MIU_LINE)>>24) & 0x0F)); //DMA Reader Base Addr[27:24]
6527
6528 HAL_AUDIO_WriteMaskReg(0x2B86, 0xFFFF, audio_pcm_dmaRdr_bufSz/BYTES_IN_MIU_LINE); //setting : DMA Reader Size
6529 HAL_AUDIO_WriteMaskReg(0x2B88, 0xFFFF, audio_pcm_dmaRdr_bufSz - 12); //setting : DMA Reader Overrun Thr
6530 HAL_AUDIO_WriteMaskReg(0x2B8A, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
6531
6532 /* synthersizer setting update */ //DMA reader
6533 HAL_AUDIO_WriteMaskByte(0x2CA4, 0x20, 0x20); //enable DMA synthesizer
6534 HAL_AUDIO_WriteMaskReg(0x2CB0, 0x6000, (divisor << 13)); //Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH
6535 HAL_AUDIO_WriteMaskReg(0x2C20, 0xFFFF, synthrate); //DMA synthesizer N.F.
6536
6537 /* Reset and Start DMA Reader */
6538 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x6402);
6539 AUDIO_DELAY1MS(1);
6540 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFF, 0x2402);
6541
6542 /* Clear DMA Reader buffer */
6543 for ( i = 0; i < (HW_DMA_RDR1_BUF_SIZE/4); i++ )
6544 {
6545 tmp1 = 0;
6546 tmp2 = 0;
6547 tmp3 = 0;
6548 tmp4 = 0;
6549
6550 *dmaReader_writePtr++ = tmp1;
6551 *dmaReader_writePtr++ = tmp2;
6552 *dmaReader_writePtr++ = tmp3;
6553 *dmaReader_writePtr++ = tmp4;
6554 }
6555
6556 /* Reset Write Pointer */
6557 dmaReader_writePtr = dmaReader_bufStartAddress;
6558 }
6559
6560 ////////////////////////////////////////////////////////////////////////////////
6561 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_Init()
6562 /// @brief \b Function \b Description: This routine is used to initilize DMA Reader.
6563 /// @param <IN> \b eType : sampleRate of PCM
6564 /// @param <OUT> \b NONE :
6565 /// @param <RET> \b NONE :
6566 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_AllInput_Init(void)6567 void HAL_AUDIO_DmaReader_AllInput_Init(void)
6568 {
6569 HAL_AUDIO_DmaReader_Init(SAMPLE_RATE_48000);
6570 return;
6571 }
6572
6573 ////////////////////////////////////////////////////////////////////////////////
6574 /// @brief \b Function \b Name: HAL_AUDIO_DmaReader_WritePCM()
6575 /// @brief \b Function \b Description: This routine is used to write PCM data into DMA reader Buffer
6576 /// @param <IN> \b eType : buffer bytes
6577 /// @param <OUT> \b NONE : TRUE or FALSE
6578 /// @param <RET> \b NONE :
6579 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DmaReader_WritePCM(void * buffer,MS_U32 bytes)6580 MS_BOOL HAL_AUDIO_DmaReader_WritePCM(void* buffer, MS_U32 bytes)
6581 {
6582 MS_U8 *bufptr = (MS_U8 *)MS_PA2KSEG1((MS_VIRT)buffer);
6583 MS_U8 tmp1, tmp2, tmp3, tmp4, replay_flag=0;
6584 MS_U32 i, level_cnt;
6585
6586 // Mask LEVEL_CNT_MASK before read
6587 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
6588 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
6589 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
6590
6591 if ( level_cnt <= 6 )
6592 {
6593 if ((HAL_AUDIO_ReadReg(0x2B80) & 0x0001) == 0x0001)
6594 replay_flag = 1;
6595
6596 /* reset dma reader */
6597 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, 0x0000); //clear wr cntrs
6598
6599 /* Reset and Start DMA Reader */
6600 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x6402);
6601 AUDIO_DELAY1MS(1);
6602 HAL_AUDIO_WriteMaskReg(0x2B80, 0xFFFE, 0x2402);
6603
6604 /* Reset Write Pointer */
6605 dmaReader_writePtr = dmaReader_bufStartAddress;
6606
6607 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "***** Audio DMAReader Buffer empty !! ***** \r\n");
6608 }
6609
6610 // Mask LEVEL_CNT_MASK before read
6611 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0010);
6612 level_cnt = HAL_AUDIO_ReadReg(0x2B8C);
6613 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0010, 0x0000);
6614 if(level_cnt < (HW_DMA_RDR1_BUF_SIZE - bytes*2)/BYTES_IN_MIU_LINE)
6615 {
6616 for ( i = 0; i < (bytes/2); i++ )
6617 {
6618 tmp1 = 0;
6619 tmp2 = *bufptr++;
6620 tmp3 = *bufptr++;
6621 tmp4 = 0;
6622
6623 *dmaReader_writePtr++ = tmp1;
6624 *dmaReader_writePtr++ = tmp2;
6625 *dmaReader_writePtr++ = tmp3;
6626 *dmaReader_writePtr++ = tmp4;
6627
6628 if ( dmaReader_writePtr >= dmaReader_bufEndAddress )
6629 dmaReader_writePtr = dmaReader_bufStartAddress;
6630 }
6631 HAL_AUDIO_WriteMaskReg(0x2B82, 0xFFFF, bytes*2/BYTES_IN_MIU_LINE);
6632 AUDIO_DELAY1US(5); // To prevent slow update of level_cnt
6633
6634 if (replay_flag == 1)
6635 {
6636 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0001, 0x0001);
6637 AUDIO_DELAY1MS(1);
6638 HAL_AUDIO_WriteMaskReg(0x2B80, 0x0100, 0x0100);
6639 }
6640 return TRUE;
6641 }
6642 return FALSE;
6643 }
6644
6645 ////////////////////////////////////////////////////////////////////////////////
6646 /// @brief \b Function \b Name: HAL_AUDIO_SetEntertainmentMode()
6647 /// @brief \b Function \b Description: This routine is used to switch the DTV/KTV/GAME mode
6648 /// @param <IN> \b eMode :
6649 /// @param <RET> \b NONE :
6650 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)6651 void HAL_AUDIO_SetEntertainmentMode(AUDIO_ENTERTAINMENT_MODE eMode)
6652 {
6653 switch((int)eMode)
6654 {
6655 case AUDIO_ETMODE_DTV :
6656 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
6657 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x00);
6658 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
6659 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x00); // ADC0 gain 0dB
6660 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
6661 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
6662 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
6663 break;
6664
6665 case AUDIO_ETMODE_KTV :
6666 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
6667 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
6668 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x80); // enable KTV function
6669 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x80); // ADC0 gain 6dB
6670 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
6671 HAL_AUDIO_WriteMaskReg(REG_SNDR2_ADVSND_SEL, 0xFF00, 0x1E00); // Switch R2 to KTV mode
6672 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
6673 break;
6674
6675 case AUDIO_ETMODE_KTV2 : // Use I2S input ; not MicroPhone in
6676 //HAL_AUDIO_SetInputPath(AUDIO_DSP1_DVB_INPUT , AUDIO_PATH_5);
6677 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x08);
6678 HAL_AUDIO_WriteMaskByte(0x2D47 , 0xF0, 0xA0); // enable KTV mode; Skyworth (stone) model
6679 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
6680 HAL_AUDIO_WriteMaskByte(0x2D5D , 0x80, 0x80); // Mute MIC volume (only mix MP3 & PCM DMA data)
6681 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_MIXER); // MIC + PCM
6682 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
6683 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
6684 break;
6685
6686 case AUDIO_ETMODE_GAME :
6687 //HAL_AUDIO_SetInputPath(AUDIO_DSP2_DVB_INPUT , AUDIO_PATH_5);
6688 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
6689 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
6690 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
6691 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
6692 //HAL_AUDIO_WriteMaskReg(REG_AUR2_ADVSND_SEL, 0xFF00, 0x0000); // Switch R2 to normal mode
6693 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
6694 break;
6695
6696 case AUDIO_ETMODE_VOIP_ON:
6697 //Voip will setup snd system to GAME MODE,
6698 //In GAME MODE, Voip used 0x2D46[7:0] to
6699 //upload Raw_Delay_SE to DRAM.
6700 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0xA1);
6701
6702 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
6703 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xE0);
6704 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0xC4);
6705
6706 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
6707 AUDIO_DELAY1MS(1);
6708 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
6709 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
6710
6711 #if 0
6712 //config SRC to 8KHz
6713 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xF0);//0xE0}, // Group A SRC rate
6714 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x03);//0x07},
6715 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0xF0);//0x50},
6716 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0xD2);//0x46},
6717 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
6718 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x04);//0x08},
6719 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0xF0);//0x50},
6720 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0xD2);//0x46},
6721 //update SYNTH
6722 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
6723 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
6724 AUDIO_DELAY1MS(1);
6725 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
6726 //reset GroupA SRC
6727 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
6728 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
6729 AUDIO_DELAY1MS(1);
6730 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
6731 #endif
6732
6733 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_ON\r\n");
6734 break;
6735
6736 case AUDIO_ETMODE_VOIP_OFF:
6737 //disable upload Raw_Delay_SE to DRAM.
6738 HAL_AUDIO_WriteMaskByte(0x2D46, 0xFF, 0x00);
6739
6740 HAL_AUDIO_WriteMaskByte(0x2C9C, 0xFF, 0x00);
6741 HAL_AUDIO_WriteMaskByte(0x2C9E, 0xFF, 0xD0);
6742 HAL_AUDIO_WriteMaskByte(0x2C9F, 0xFF, 0x20);
6743
6744 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x40);
6745 AUDIO_DELAY1MS(1);
6746 HAL_AUDIO_WriteMaskByte(0x2C9D, 0x40, 0x00);
6747 HAL_MAD_SetCommInfo(Audio_Comm_infoType_SoundMode, AU_DVB_MODE_STEREO, 0); // Switch SE-DSP sound mode to stereo
6748
6749 #if 0
6750 //set SRC back to 48KHz
6751 HAL_AUDIO_WriteMaskByte(0x2BBC, 0xFF, 0xE0); // Group A SRC rate
6752 HAL_AUDIO_WriteMaskByte(0x2BBD, 0xFF, 0x07);
6753 HAL_AUDIO_WriteMaskByte(0x2BBE, 0xFF, 0x50);
6754 HAL_AUDIO_WriteMaskByte(0x2BBF, 0xFF, 0x46);
6755 HAL_AUDIO_WriteMaskByte(0x2BC0, 0xFF, 0x00);
6756 HAL_AUDIO_WriteMaskByte(0x2BC1, 0xFF, 0x08);
6757 HAL_AUDIO_WriteMaskByte(0x2BC2, 0xFF, 0x50);
6758 HAL_AUDIO_WriteMaskByte(0x2BC3, 0xFF, 0x46);
6759 //update SYNTH
6760 //HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
6761 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x40);
6762 AUDIO_DELAY1MS(1);
6763 HAL_AUDIO_WriteMaskByte(0x2BCE, 0x40, 0x00);
6764 //reset GroupA SRC
6765 //HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
6766 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x80);
6767 AUDIO_DELAY1MS(1);
6768 HAL_AUDIO_WriteMaskByte(0x2B44, 0x80, 0x00);
6769 #endif
6770 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "HAL_AUDIO_SetEntertainmentMode: AUDIO_ETMODE_VOIP_OFF\r\n");
6771 break;
6772
6773 default :
6774 break;
6775 }
6776 }
6777
6778
6779 ////////////////////////////////////////////////////////////////////////////////
6780 /// @brief \b Function \b Name: HAL_AUDIO_SetSystem()
6781 /// @brief \b Function \b Description: This function will load
6782 /// different audio decoder to audio system.
6783 ///
6784 /// In Mstar audio system, we can support 1 or 2 decoders.
6785 /// One is for main DTV audio or Multimedia audio player.
6786 /// Another is for second audio decode (ex: used for Audio Description purpose)
6787 ///
6788 /// @param enDecSystem \b : (En_DVB_decSystemType) decoder type
6789 /// - parameter type "MSAPI_AUD_DVB_XXXX" is decoder type for main audio decoder
6790 /// - parameter type "MSAPI_AUD_DVB2_XXXX" is decoder type for second audio decoder
6791 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)6792 MS_BOOL HAL_AUDIO_SetSystem(En_DVB_decSystemType enDecSystem)
6793 {
6794 MS_BOOL bRet = TRUE;
6795 En_DVB_decSystemType eDecSystemType = MSAPI_AUD_DVB_INVALID;
6796 AUDIO_DEC_ID eDecId = AU_DEC_ID1;
6797
6798 HALAUDIO_CHECK_SHM_INIT;
6799
6800 HAL_AUDIO_SetIsDtvFlag(TRUE);
6801 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, FALSE, 0);
6802
6803 // set decoder system
6804 switch (enDecSystem)
6805 {
6806 ////////////////////////////////////////////////
6807 // Audio Decoder 1
6808 ////////////////////////////////////////////////
6809 case MSAPI_AUD_DVB_MPEG:
6810 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
6811 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
6812 eDecId = AU_DEC_ID1;
6813 eDecSystemType = MSAPI_AUD_DVB_MPEG;
6814 break;
6815
6816 case MSAPI_AUD_DVB_AC3:
6817 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6818 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6819 AUDIO_DELAY1MS(1);
6820 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6821 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6822 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3, TRUE);
6823 eDecId = AU_DEC_ID1;
6824 eDecSystemType = MSAPI_AUD_DVB_AC3;
6825 break;
6826
6827 case MSAPI_AUD_DVB_AC3P:
6828 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6829 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6830 AUDIO_DELAY1MS(1);
6831 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6832 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6833 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
6834 eDecId = AU_DEC_ID1;
6835 eDecSystemType = MSAPI_AUD_DVB_AC3P;
6836 break;
6837
6838 case MSAPI_AUD_DVB_MP3:
6839 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_mpeg);
6840 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MP3, TRUE);
6841 eDecId = AU_DEC_ID1;
6842 eDecSystemType = MSAPI_AUD_DVB_MP3;
6843 break;
6844
6845 case MSAPI_AUD_DVB_AAC:
6846 case MSAPI_AUD_DVB_MS10_DDT:
6847 if (g_AudioVars2->DolbyAACFlag == 1)
6848 {
6849 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_aac);
6850 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDT, TRUE);
6851 }
6852 else
6853 {
6854 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_gaac);
6855 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
6856 }
6857 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6858 eDecId = AU_DEC_ID1;
6859 eDecSystemType = MSAPI_AUD_DVB_AAC;
6860 break;
6861
6862 case MSAPI_AUD_DVB_XPCM:
6863 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_xpcm);
6864 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
6865 eDecId = AU_DEC_ID1;
6866 eDecSystemType = MSAPI_AUD_DVB_XPCM;
6867 break;
6868
6869 case MSAPI_AUD_DVB_RA8LBR:
6870 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ra8);
6871 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
6872 eDecId = AU_DEC_ID1;
6873 eDecSystemType = MSAPI_AUD_DVB_RA8LBR;
6874 break;
6875
6876 case MSAPI_AUD_DVB_WMA:
6877 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
6878 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
6879 eDecId = AU_DEC_ID1;
6880 eDecSystemType = MSAPI_AUD_DVB_WMA;
6881 break;
6882
6883 case MSAPI_AUD_DVB_DTS:
6884 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL, 0x08, 0x00); // select ADEC DSP NPCM
6885 AUDIO_DELAY1MS(1);
6886 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
6887 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
6888 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
6889 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
6890 eDecId = AU_DEC_ID1;
6891 eDecSystemType = MSAPI_AUD_DVB_DTS;
6892 break;
6893
6894 case MSAPI_AUD_DVB_DTSLBR:
6895 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dts);
6896 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTSLBR, TRUE);
6897 eDecId = AU_DEC_ID1;
6898 eDecSystemType = MSAPI_AUD_DVB_DTSLBR;
6899 break;
6900
6901 case MSAPI_AUD_DVB_MS10_DDC:
6902 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_ac3);
6903 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MS10_DDC, TRUE);
6904 eDecId = AU_DEC_ID1;
6905 eDecSystemType = MSAPI_AUD_DVB_AC3P;
6906 break;
6907
6908 case MSAPI_AUD_DVB_WMA_PRO:
6909 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_wma);
6910 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
6911 eDecId = AU_DEC_ID1;
6912 eDecSystemType = MSAPI_AUD_DVB_WMA_PRO;
6913 break;
6914
6915 case MSAPI_AUD_DVB_FLAC:
6916 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_flac);
6917 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
6918 eDecId = AU_DEC_ID1;
6919 eDecSystemType = MSAPI_AUD_DVB_FLAC;
6920 break;
6921
6922 case MSAPI_AUD_DVB_VORBIS:
6923 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_vorbis);
6924 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
6925 eDecId = AU_DEC_ID1;
6926 eDecSystemType = MSAPI_AUD_DVB_VORBIS;
6927 break;
6928
6929 case MSAPI_AUD_DVB_AMR_NB:
6930 eDecId = AU_DEC_ID1;
6931 eDecSystemType = MSAPI_AUD_DVB_AMR_NB;
6932 break;
6933
6934 case MSAPI_AUD_DVB_AMR_WB:
6935 eDecId = AU_DEC_ID1;
6936 eDecSystemType = MSAPI_AUD_DVB_AMR_WB;
6937 break;
6938
6939 case MSAPI_AUD_DVB_DRA:
6940 HAL_AUR2_WriteByte(REG_R2_DECODE1_TYPE, adec_type_dra);
6941 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
6942 eDecId = AU_DEC_ID1;
6943 eDecSystemType = MSAPI_AUD_DVB_DRA;
6944 break;
6945
6946
6947 ////////////////////////////////////////////////
6948 // Audio Decoder 2
6949 ////////////////////////////////////////////////
6950 case MSAPI_AUD_DVB2_MPEG:
6951 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
6952 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
6953 eDecId = AU_DEC_ID3;
6954 eDecSystemType = MSAPI_AUD_DVB_MPEG;
6955 break;
6956
6957 case MSAPI_AUD_DVB2_AC3:
6958 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
6959 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3, TRUE);
6960 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6961 eDecId = AU_DEC_ID3;
6962 eDecSystemType = MSAPI_AUD_DVB_AC3;
6963 break;
6964
6965 case MSAPI_AUD_DVB2_MP3:
6966 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_mpeg); // MP3 & MPEG use the same decoder
6967 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MP3, TRUE);
6968 eDecId = AU_DEC_ID3;
6969 eDecSystemType = MSAPI_AUD_DVB_MP3;
6970 break;
6971
6972 case MSAPI_AUD_DVB2_AAC:
6973 case MSAPI_AUD_DVB2_GAAC:
6974 if (g_AudioVars2->DolbyAACFlag == 1)
6975 {
6976 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_aac);
6977 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
6978 }
6979 else
6980 {
6981 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_gaac);
6982 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
6983 }
6984 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6985 eDecId = AU_DEC_ID3;
6986 eDecSystemType = MSAPI_AUD_DVB_AAC;
6987 break;
6988
6989 case MSAPI_AUD_DVB2_AC3P:
6990 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_ac3);
6991 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
6992 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
6993 eDecId = AU_DEC_ID3;
6994 eDecSystemType = MSAPI_AUD_DVB_AC3P;
6995 break;
6996
6997 case MSAPI_AUD_DVB2_DTS:
6998 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_dts);
6999 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
7000 eDecId = AU_DEC_ID3;
7001 eDecSystemType = MSAPI_AUD_DVB_DTS;
7002 break;
7003
7004 case MSAPI_AUD_DVB2_XPCM:
7005 HAL_AUR2_WriteByte(REG_R2_DECODE2_TYPE, adec_type_xpcm);
7006 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
7007 eDecId = AU_DEC_ID3;
7008 eDecSystemType = MSAPI_AUD_DVB_XPCM;
7009 break;
7010
7011 default:
7012 HAL_AUDIO_SetIsDtvFlag(FALSE);
7013 bRet = FALSE;
7014 break;
7015 }
7016
7017 if (bRet == TRUE)
7018 {
7019 g_AudioVars2->AudioDecStatus[eDecId].eAudFormat = eDecSystemType;
7020 }
7021
7022 return bRet;
7023 }
7024
7025 ////////////////////////////////////////////////////////////////////////////////
7026 /// @brief \b Function \b Name: HAL_AUDIO_GetDecSysSupportStatus()
7027 /// @brief \b Function \b Description: This function will report Audio Decoder support feature status when giving DecSystem type
7028 /// @param <IN> \b enDecSystem : Decoder type
7029 /// @param <RET> \b BOOL : True or False
7030 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)7031 MS_BOOL HAL_AUDIO_GetDecSysSupportStatus(En_DVB_decSystemType enDecSystem)
7032 {
7033 MS_BOOL SetDecSys_RtnStatus = FALSE;
7034 switch (enDecSystem)
7035 {
7036 ////////////////////////////////////////////////
7037 // Audio Decoder 1
7038 ////////////////////////////////////////////////
7039 case MSAPI_AUD_DVB_MPEG:
7040 case MSAPI_AUD_DVB_AC3:
7041 case MSAPI_AUD_DVB_AC3P:
7042 case MSAPI_AUD_DVB_MP3:
7043 case MSAPI_AUD_DVB_AAC:
7044 SetDecSys_RtnStatus = TRUE;
7045 break;
7046
7047 case MSAPI_AUD_DVB_MS10_DDT:
7048 case MSAPI_AUD_DVB_MS10_DDC:
7049 SetDecSys_RtnStatus = TRUE;
7050 break;
7051
7052 case MSAPI_AUD_DVB_XPCM:
7053 case MSAPI_AUD_DVB_RA8LBR:
7054 SetDecSys_RtnStatus = TRUE;
7055 break;
7056
7057 case MSAPI_AUD_DVB_WMA:
7058 case MSAPI_AUD_DVB_WMA_PRO:
7059 SetDecSys_RtnStatus = TRUE;
7060 break;
7061
7062 case MSAPI_AUD_DVB_DTS:
7063 SetDecSys_RtnStatus = TRUE;
7064 break;
7065
7066 case MSAPI_AUD_DVB_FLAC:
7067 SetDecSys_RtnStatus = TRUE;
7068 break;
7069
7070 case MSAPI_AUD_DVB_VORBIS:
7071 SetDecSys_RtnStatus = TRUE;
7072 break;
7073
7074 case MSAPI_AUD_DVB_AMR_NB:
7075 SetDecSys_RtnStatus = FALSE;
7076 break;
7077
7078 case MSAPI_AUD_DVB_AMR_WB:
7079 SetDecSys_RtnStatus = FALSE;
7080 break;
7081
7082 ////////////////////////////////////////////////
7083 // Audio Decoder 2
7084 ////////////////////////////////////////////////
7085 case MSAPI_AUD_DVB2_MPEG:
7086 case MSAPI_AUD_DVB2_MP3:
7087 SetDecSys_RtnStatus = TRUE;
7088 break;
7089
7090 case MSAPI_AUD_DVB2_AC3:
7091 case MSAPI_AUD_DVB2_AC3P:
7092 SetDecSys_RtnStatus = TRUE;
7093 break;
7094
7095 case MSAPI_AUD_DVB2_AAC:
7096 SetDecSys_RtnStatus = TRUE;
7097 break;
7098
7099 case MSAPI_AUD_DVB2_DDE:
7100 SetDecSys_RtnStatus = FALSE;
7101 break;
7102
7103 case MSAPI_AUD_DVB2_DTSE:
7104 SetDecSys_RtnStatus = FALSE;
7105 break;
7106
7107 case MSAPI_AUD_DVB2_XPCM:
7108 SetDecSys_RtnStatus = TRUE;
7109 break;
7110
7111 case MSAPI_AUD_DVB2_KTV:
7112 SetDecSys_RtnStatus = TRUE;
7113 break;
7114
7115 case MSAPI_AUD_DVB_TONE:
7116 case MSAPI_AUD_DVB_NONE:
7117 case MSAPI_AUD_DVB2_NONE:
7118 default:
7119 SetDecSys_RtnStatus = FALSE;
7120 break;
7121 }
7122 return(SetDecSys_RtnStatus);
7123 }
7124
7125 ////////////////////////////////////////////////////////////////////////////////
7126 /// @brief \b Function \b Name: HAL_AUDIO_AlgReloadCode()
7127 /// @brief \b Function \b Description: This routine is used to reload DSP code
7128 /// @param u8Type \b :
7129 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
7130 /// FALSE--DEC-DSP reload code fail
7131 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)7132 MS_BOOL HAL_AUDIO_AlgReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
7133 {
7134 // No DEC-DSP in Monaco
7135 return TRUE;
7136 }
7137
7138 ////////////////////////////////////////////////////////////////////////////////
7139 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Check()
7140 /// @brief \b Function \b Description: Check if ALSA Interface is supported
7141 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
7142 /// @param <OUT> \b MS_BOOL : return TRUE if it's supported, else return FALSE
7143 /// @param <RET> \b NONE :
7144 /// @param <GLOBAL> \b NONE :
7145 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Check(void)7146 MS_BOOL HAL_AUDIO_ALSA_Check(void)
7147 {
7148 return TRUE;
7149 }
7150
7151 ////////////////////////////////////////////////////////////////////////////////
7152 /// @brief \b Function \b Name: HAL_AUDIO_ALSA_Enable()
7153 /// @brief \b Function \b Description: Enable/ Disable the path of ALSA
7154 /// @param <IN> \b bEnable : on: TRUE, off: FALSE
7155 /// @param <OUT> \b MS_BOOL : return TRUE if ok, else return FALSE
7156 /// @param <RET> \b NONE :
7157 /// @param <GLOBAL> \b NONE :
7158 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)7159 MS_BOOL HAL_AUDIO_ALSA_Enable(MS_BOOL bEnable)
7160 {
7161 if (bEnable == TRUE)
7162 {
7163 /* Set as GAME mode */
7164 HAL_AUDIO_SetInputPath(AUDIO_DSP3_DVB_INPUT , AUDIO_PATH_5);
7165 HAL_AUDIO_WriteMaskByte(0x2DD9 , 0x38, 0x10);
7166 HAL_AUDIO_WriteMaskByte(0x2D47 , 0x80, 0x00); // disable KTV function
7167 HAL_AUDIO_WriteMaskByte(0x2CE5 , 0xE0, 0x40); // ADC0 gain -6dB
7168 HAL_AUDIO_WriteMaskByte(0x2D55, 0x0F, (MS_U8)INTERNAL_PCM); // Fix PCM in
7169
7170 return TRUE;
7171 }
7172 else
7173 {
7174 /* Do nothing for the moment */
7175 return FALSE;
7176 }
7177 }
7178
7179 ////////////////////////////////////////////////////////////////////////////////
7180 /// @brief \b Function \b Name: HAL_AUDIO_Alg2ReloadCode()
7181 /// @brief \b Function \b Description: This routine is used to reload the algorithm in se-dsp .
7182 /// @param u8Type \b : information of algorithm code
7183 /// @return MS_BOOL \b : TRUE --DEC-DSP reload code okay
7184 /// FALSE--DEC-DSP reload code fail
7185 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)7186 MS_BOOL HAL_AUDIO_Alg2ReloadCode(AUDIO_DSP_CODE_TYPE dspCodeType)
7187 {
7188 MS_U16 time_out;
7189 MS_BOOL ret_status = FALSE;
7190
7191 HAL_MAD2_SetDspIDMA();
7192 // Enter MCU/DSP hand-shake
7193 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
7194 {
7195 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_BEG/0x100);
7196 }
7197 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
7198 {
7199 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG/0x100);
7200 }
7201 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
7202 {
7203 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_BEG/0x100);
7204 }
7205 else
7206 {
7207 //No Decoder in DSP
7208 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Warning! un-support DSP version decoder. \r\n", __FUNCTION__);
7209 return FALSE;
7210 }
7211
7212 // PIO[8] interrupt
7213 HAL_MAD2_TriggerPIO8();
7214
7215 //Wait Dsp Start reload Ack
7216 time_out = 0;
7217 while (time_out++<2000)
7218 {
7219 if(HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1)
7220 break;
7221 AUDIO_DELAY1MS(1);
7222 }
7223 if (time_out>=2000)
7224 {
7225 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " DSP Reload timeOut1: %d\r\n", time_out);
7226 return FALSE;
7227 }
7228
7229 // Change to IDMA Port
7230 HAL_MAD2_SetDspIDMA();
7231
7232 // Start to Reload DSP code
7233 ret_status = HAL_AUDSP_DspLoadCode(dspCodeType);
7234 HAL_AUDIO_SetDsp2CodeType(dspCodeType, ret_status);
7235
7236 // Enter MCU/DSP hand-shake
7237 if (IS_AUDIO_DSP_CODE_TYPE_ADVSND(dspCodeType))
7238 {
7239 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ADVSND_END/0x100);
7240 }
7241 else if (IS_AUDIO_DSP_CODE_TYPE_SIF(dspCodeType))
7242 {
7243 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END/0x100);
7244 }
7245 else if (IS_AUDIO_DSP_CODE_TYPE_SE_ENC(dspCodeType))
7246 {
7247 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_ENC_END/0x100);
7248 }
7249 else
7250 {
7251 //No Decoder in DSP
7252 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Warning! un-support DSP version decoder. \r\n", __FUNCTION__);
7253 return FALSE;
7254 }
7255
7256 HAL_MAD2_TriggerPIO8();
7257
7258 // Wait Dsp End Reload Ack
7259 time_out = 0;
7260 while (time_out++<3000)
7261 {
7262 if (HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2)
7263 break;
7264 AUDIO_DELAY1MS(1);
7265 }
7266
7267 if (time_out>=3000)
7268 {
7269 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, " DSP Reload timeOut2: %d\r\n", time_out);
7270 return FALSE;
7271 }
7272
7273 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "HAL_AUDIO_SeReloadCode finish\r\n");
7274
7275 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
7276
7277 return TRUE;
7278
7279 }
7280
7281 ////////////////////////////////////////////////////////////////////////////////
7282 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeDoneFlag() @@Cathy
7283 /// @brief \b Function \b Description: This function is used to set the Decoder DSP ISR
7284 /// @param <IN> \b NONE :
7285 /// @param <OUT> \b NONE :
7286 /// @param <RET> \b NONE :
7287 /// @param <GLOBAL> \b NONE :
7288 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeDoneTag(void)7289 MS_U16 HAL_AUDIO_GetUniDecodeDoneTag(void)
7290 {
7291 MS_U16 temp1, temp2, i;
7292
7293 for (i = 0; i < 100; i++)
7294 {
7295 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
7296 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, ADEC1 );
7297
7298 if (temp1 == temp2)
7299 {
7300 return (temp1);
7301 }
7302 }
7303
7304 return 0;
7305 }
7306
7307 ////////////////////////////////////////////////////////////////////////////////
7308 /// @brief \b Function \b Name: HAL_AUDIO_GetUniDecodeFrameCnt()
7309 /// @brief \b Function \b Description: This function is used to get the Decoder decoded frame count
7310 /// @param <IN> \b NONE:
7311 /// @param <OUT> \b NONE:
7312 /// @param <RET> \b NONE:
7313 /// @param <GLOBAL> \b NONE:
7314 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)7315 MS_U16 HAL_AUDIO_GetUniDecodeFrameCnt(AUDIO_DEC_ID eDSPId)
7316 {
7317 MS_U16 temp1, temp2, i;
7318 Audio_id r2AudioID = ADEC1;
7319
7320
7321 if (eDSPId == AU_DEC_ID3)
7322 {
7323 r2AudioID = ADEC2;
7324 }
7325
7326 for ( i = 0; i < 100; i++ )
7327 {
7328 temp1 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
7329 temp2 = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_UNI_DECODE_DONE_CNT, r2AudioID);
7330
7331 if ( temp1 == temp2 )
7332 {
7333 return (temp1);
7334 }
7335 }
7336
7337 return 0;
7338 }
7339
7340 //******************************************************************************
7341 // [Function Name]:
7342 // HAL_AUDIO_PTS_info
7343 // [Description]:
7344 // get PTS and OS time or set to reset these reference
7345 // [Arguments]:
7346 //
7347 //*******************************************************************************
HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info)7348 void HAL_AUDIO_PTS_info(MS_VIRT access_PTS_info )
7349 {
7350 AUDIO_PTS_INFO PTS_info;
7351
7352 memcpy((void *)&PTS_info, (void *)access_PTS_info, sizeof(AUDIO_PTS_INFO));
7353
7354 // AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "HAL_AUDIO_PTS_info((0x%x, %d, %lld))\n",(unsigned int)access_PTS_info,(int)PTS_info.os_Time,PTS_info.curPTS);
7355 if (PTS_info.set2Clr) //setting value
7356 {
7357 curr_OS_Time = PTS_info.os_Time;
7358 curr_PTS = PTS_info.curPTS;
7359 }
7360 else // get PTS information
7361 {
7362 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
7363
7364 PTS_info.set2Clr = 0 ;
7365 PTS_info.os_Time = curr_OS_Time;
7366 PTS_info.curPTS = curr_PTS;
7367
7368 memcpy((void *)access_PTS_info, (void *)&PTS_info, sizeof(AUDIO_PTS_INFO));
7369
7370 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
7371 }
7372 }
7373
HAL_AUDIO_DmaWriter_Init(void)7374 void HAL_AUDIO_DmaWriter_Init(void)
7375 {
7376 MS_U32 audio_pcm_dmaWtr_bufSz = HW_DMA_WTR1_BUF_SIZE; //must be multiple of DMA_RDR_PCM_BUF_UNIT*2 = 0x2000
7377 MS_PHY audio_pcm_dmaWtr_base = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR; // DMA Reader Input buffer (DM_Prefetch)
7378
7379 /* init DMA writer address */
7380 dmaWriter_readPtr = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base);
7381 dmaWriter_bufStartAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base);
7382 dmaWriter_bufEndAddress = (MS_U8 *) MS_PA2KSEG1(audio_pcm_dmaWtr_base + audio_pcm_dmaWtr_bufSz);
7383 // AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\n\ndmaReader_writePtr dmaReader_bufStartAddress: %lx\n", audio_pcm_dmaWtr_base);
7384
7385 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
7386 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (audio_pcm_dmaWtr_base/BYTES_IN_MIU_LINE) & 0xFFFF);
7387 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (audio_pcm_dmaWtr_base/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
7388 HAL_AUDIO_AbsWriteReg(NewDMAwriter_DRAM_size, audio_pcm_dmaWtr_bufSz/BYTES_IN_MIU_LINE);
7389 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
7390
7391 /* Reset and Start DMA Writer */
7392 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
7393 AUDIO_DELAY1US(1);
7394 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
7395
7396 /* Reset Write Pointer */
7397 dmaWriter_readPtr = dmaWriter_bufStartAddress;
7398 }
7399
HAL_AUDIO_DmaWriter_Read(void * buffer,MS_U32 bytes)7400 MS_BOOL HAL_AUDIO_DmaWriter_Read(void* buffer, MS_U32 bytes)
7401 {
7402 MS_U8 *bufptr;
7403 MS_U16 DRAM_levelcnt = 0, DRAM_levelcnt1;
7404 MS_U32 DRAM_levelcnt_bytes = 0;
7405 MS_U32 i;
7406
7407 bytes = (bytes/BYTES_IN_MIU_LINE)*BYTES_IN_MIU_LINE;
7408 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
7409 DRAM_levelcnt = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
7410 while (DRAM_levelcnt1 != DRAM_levelcnt)
7411 {
7412 DRAM_levelcnt1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
7413 DRAM_levelcnt = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt);
7414 }
7415 if (DRAM_levelcnt < (bytes/BYTES_IN_MIU_LINE))
7416 return FALSE;
7417
7418 bufptr = buffer;
7419 DRAM_levelcnt_bytes = DRAM_levelcnt*BYTES_IN_MIU_LINE;
7420 DRAM_levelcnt_bytes = (DRAM_levelcnt_bytes > bytes) ? bytes : DRAM_levelcnt_bytes;
7421
7422 for (i = 0; i < (DRAM_levelcnt_bytes/4); i++)
7423 {
7424 *bufptr++ = *dmaWriter_readPtr++;
7425 *bufptr++ = *dmaWriter_readPtr++;
7426 *bufptr++ = *dmaWriter_readPtr++;
7427 *bufptr++ = *dmaWriter_readPtr++;
7428
7429 if ( dmaWriter_readPtr >= dmaWriter_bufEndAddress)
7430 dmaWriter_readPtr = dmaWriter_bufStartAddress;
7431 }
7432
7433 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "D %x\n", DRAM_levelcnt);
7434 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
7435 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, DRAM_levelcnt_bytes/BYTES_IN_MIU_LINE);
7436 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
7437 bytes -= DRAM_levelcnt_bytes;
7438 return TRUE;
7439 }
7440
7441 ////////////////////////////////////////////////////////////////////////////////
7442 /// @brief \b Function \b Name: HAL_AUDIO_RebootDecDSP()
7443 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_RebootDecDSP(void)7444 void HAL_AUDIO_RebootDecDSP(void)
7445 {
7446 AUDIO_DSP_CODE_TYPE DspCodeType;
7447 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "\n*MAD Auto-Recovery DSP1* \n");
7448
7449 HALAUDIO_CHECK_SHM_INIT;
7450
7451 g_AudioVars2->g_u8AudioCrashFlag = TRUE;
7452
7453 DspCodeType = HAL_AUDIO_GetDspCodeType();
7454
7455 // Reset MAD module
7456 HAL_MAD_RSTMAD_DisEn_MIUREQ();
7457 AUDIO_DELAY1MS(2);
7458
7459 //if((u8DspCodeType & 0xF0) != 0x10 )
7460 {
7461 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, FALSE, 0); // Audio SIF channel enable setting -> disable
7462 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 0, 0);
7463
7464 AUDIO_DELAY1MS(2);
7465 }
7466 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "*** Load code and reset DEC DSP \n");
7467 HAL_MAD_SetMemInfo();
7468 HAL_AUDIO_ResetDSP();
7469 HAL_AUDIO_DecoderLoadCode();
7470
7471 //if((u8DspCodeType & 0xF0) != 0x10 )
7472 {
7473 AUDIO_DELAY1MS(50);
7474 HAL_SIF_SendCmd(AU_SIF_CMD_SET_SIFFIFO_MODE, 1, 0);
7475 HAL_SIF_SendCmd(AU_SIF_CMD_ENABLE_CHANNEL, TRUE, 0); // Audio SIF channel enable setting -> enable
7476 }
7477 }
7478
7479 ////////////////////////////////////////////////////////////////////////////////
7480 /// @brief \b Function \b Name: HAL_AUDIO_DspReboot()
7481 /// @brief \b Function \b Description: This routine is used to do dsp reboot and some specific setting
7482 /// @param <IN> \b eType : param
7483 /// @param <RET> \b NONE :
7484 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DspReboot(MS_U8 alive)7485 void HAL_AUDIO_DspReboot(MS_U8 alive)
7486 {
7487 alive = alive;
7488 }
7489
7490
7491 ////////////////////////////////////////////////////////////////////////////////
7492 /// @brief \b Function \b Name: HAL_AUDIO_ReadDspCounter()
7493 /// @brief \b Function \b Description: Read the DSP running counter
7494 /// @param CounterType \b :
7495 /// - DSP_DEC_MAIN_COUNTER ==> Decoder DSP Main loop counter
7496 /// - DSP_DEC_TIMER_COUNTER ==> Decoder Timer counter
7497 /// - DSP_SE_MAIN_COUNTER ==> SE DSP Main loop counter
7498 /// - DSP_SE_TIMER_COUNTER ==> SE Timer counter
7499 /// - DSP_SE_ISR_COUNTER ==> SE Interrupt ISR counter
7500 /// - DEC_R2_MAIN_COUNTER ==> DEC R2 Main loop counter
7501 /// - DEC_R2_TIMER_COUNTER ==> DEC R2 Timer counter
7502 /// - SND_R2_MAIN_COUNTER ==> SND R2 Main loop counter
7503 /// - SND_R2_TIMER_COUNTER ==> SND R2 Timer counter
7504 /// @return MS_U8 \b : Running counter value
7505 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)7506 MS_U8 HAL_AUDIO_ReadDspCounter(AUDIO_DSP_COUNTER_TYPE CounterType)
7507 {
7508 MS_U8 u8CounterValue=0;
7509
7510 switch(CounterType)
7511 {
7512 case DSP_DEC_MAIN_COUNTER:
7513 break;
7514
7515 case DSP_DEC_TIMER_COUNTER:
7516 break;
7517
7518 case DSP_SE_MAIN_COUNTER:
7519 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_COUNTER);
7520 break;
7521
7522 case DSP_SE_TIMER_COUNTER:
7523 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_TIMER_COUNTER);
7524 break;
7525
7526 case DSP_SE_ISR_COUNTER:
7527 u8CounterValue = HAL_AUDIO_ReadByte(REG_SOUND_ISR_COUNTER);
7528 break;
7529
7530 case DEC_R2_MAIN_COUNTER:
7531 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_MAIN_COUNTER);
7532 break;
7533
7534 case DEC_R2_TIMER_COUNTER:
7535 u8CounterValue = HAL_AUR2_ReadByte(REG_DECR2_TIMER_COUNTER);
7536 break;
7537
7538 case SND_R2_MAIN_COUNTER:
7539 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_MAIN_COUNTER);
7540 break;
7541
7542 case SND_R2_TIMER_COUNTER:
7543 u8CounterValue = HAL_AUR2_ReadByte(REG_SNDR2_TIMER_COUNTER);
7544 break;
7545
7546 default:
7547 break;
7548 }
7549 return u8CounterValue;
7550 }
7551
7552
7553 ////////////////////////////////////////////////////////////////////////////////
7554 /// @brief \b Function \b Name: HAL_AuProcessPowerDown_Wait()
7555 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
7556 /// @param bEnable \b : TRUE --Not wait,
7557 /// FALSE--wait
7558 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)7559 void HAL_AUDIO_SetPowerDownWait(MS_BOOL bEnable)
7560 {
7561 bEnable = bEnable;
7562 }
7563
7564 ////////////////////////////////////////////////////////////////////////////////
7565 /// @brief \b Function \b Name: HAL_AUDIO_SendIntrupt()
7566 /// @brief \b Function \b Description: send a PIO8 interrupt to DSP
7567 /// @param bDspType \b :
7568 /// @param u8Cmd \b :
7569 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)7570 void HAL_AUDIO_SendIntrupt(MS_BOOL bDspType,MS_U16 u8Cmd)
7571 {
7572 if (bDspType == DSP_DEC)
7573 {
7574 HAL_MAD_SetPIOCmd(u8Cmd);
7575 HAL_MAD_TriggerPIO8();
7576 }
7577 else
7578 {
7579 HAL_MAD2_SetPIOCmd(u8Cmd);
7580 HAL_MAD2_TriggerPIO8();
7581 }
7582 }
7583
7584 ////////////////////////////////////////////////////////////////////////////////
7585 /// @brief \b Function \b Name: HAL_AUDIO_SeSystemLoadCode()
7586 /// @brief \b Function \b Description: This routine is used to load DSP code for SE-DSP .
7587 /// @return MS_BOOL \b : TRUE --DEC-DSP load code okay,
7588 /// FALSE--DEC-DSP load code fail
7589 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SeSystemLoadCode(void)7590 MS_BOOL HAL_AUDIO_SeSystemLoadCode(void)
7591 {
7592 MS_U16 time_out = 0;
7593
7594 HAL_MAD2_SetDspIDMA();
7595
7596 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MDrv_AUDIO_SeSystemLoadCode() \r\n");
7597
7598 HAL_AUDSP_DspLoadCode(AU_SE_SYSTEM);
7599
7600 //Wait Dsp init finished Ack
7601 #ifndef CONFIG_MBOOT
7602 while(time_out++<100) {
7603 if((HAL_MAD2_GetLoadCodeAck() == 0xE3)&&(HAL_AUDIO_ReadByte(0x2EAE) == 0xE3))
7604 break;
7605 AUDIO_DELAY1MS(2);
7606 }
7607 #endif
7608
7609 if (time_out>=100) {
7610 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "DSP2 Re-Active\n");
7611 }
7612 else {
7613 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "audio DSP_SE LoadCode success..\n");
7614 }
7615
7616 //inform DSP to start to run
7617 HAL_MAD2_SetMcuCmd(0xF3);
7618
7619 return TRUE;
7620 }
7621
7622 ////////////////////////////////////////////////////////////////////////////////
7623 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
7624 ////////////////////////////////////////////////////////////////////////////////
7625 ////////////////////////////////////////////////////////////////////////////////
7626 /// @brief \b Function \b Name: HAL_AUDIO_DecoderLoadCode()
7627 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DecoderLoadCode(void)7628 MS_BOOL HAL_AUDIO_DecoderLoadCode(void)
7629 {
7630 return TRUE;
7631 }
7632
7633 ////////////////////////////////////////////////////////////////////////////////
7634 /// @brief \b Function \b Name: HAL_AUDIO_init()
7635 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Init(MS_BOOL Initype)7636 MS_BOOL HAL_AUDIO_Init(MS_BOOL Initype)
7637 {
7638 Initype = Initype;
7639 return Initype;
7640 }
7641
7642 ////////////////////////////////////////////////////////////////////////////////
7643 /// @brief \b Function \b Name: HAL_AUDIO_HDMI_TX_SetMode()
7644 /// @brief \b Function \b Description: This routine is used to set HDMI output mode
7645 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType,AUDIO_SOURCE_INFO_TYPE eSource)7646 void HAL_AUDIO_HDMI_TX_SetMode(HDMI_TX_OUTPUT_TYPE outType, AUDIO_SOURCE_INFO_TYPE eSource)
7647 {
7648 outType = outType;
7649 eSource = eSource;
7650 }
7651
7652 ////////////////////////////////////////////////////////////////////////////////
7653 /// @brief \b Function \b Name: HAL_AUDIO_PCMCaptureInit()
7654 /// @brief \b Function \b Description: Select source for pcm capture
7655 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7656 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
7657 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7658 /// @param <RET> \b NONE :
7659 /// @param <GLOBAL> \b NONE :
7660 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID,const AUDIO_CAPTURE_SOURCE_TYPE eSource)7661 MS_BOOL HAL_AUDIO_PCMCapture_Init(const AUDIO_DEVICE_TYPE eID, const AUDIO_CAPTURE_SOURCE_TYPE eSource)
7662 {
7663 MS_BOOL ret = TRUE;
7664
7665 switch(eID)
7666 {
7667 case E_DEVICE0:
7668 g_pcm_capture_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
7669 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
7670 ret = HAL_AUDIO_PCMCapture_Stop(eID);
7671 break;
7672
7673 case E_DEVICE1:
7674 g_pcm_capture2_base_addr = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
7675 ret = HAL_AUDIO_SetDataCaptureSource(eID, eSource);
7676 ret = HAL_AUDIO_PCMCapture_Stop(eID);
7677 break;
7678
7679 default:
7680 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Init : unsupported DEVICE TYPE!!!=======");
7681 ret = FALSE;
7682 break;
7683 }
7684
7685 return ret;
7686 }
7687
7688 ////////////////////////////////////////////////////////////////////////////////
7689 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Start()
7690 /// @brief \b Function \b Description: captrue pcm data to DDR
7691 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7692 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7693 /// @param <RET> \b NONE :
7694 /// @param <GLOBAL> \b NONE :
7695 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)7696 MS_BOOL HAL_AUDIO_PCMCapture_Start(const AUDIO_DEVICE_TYPE eID)
7697 {
7698 MS_BOOL ret = TRUE;
7699
7700 switch(eID)
7701 {
7702 case E_DEVICE0:
7703 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); // start
7704 break;
7705
7706 case E_DEVICE1:
7707 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE); //start
7708 break;
7709
7710 default:
7711 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Start : unsupported DEVICE TYPE!!!=======");
7712 ret = FALSE;
7713 break;
7714 }
7715
7716 return ret;
7717 }
7718
7719
7720 ////////////////////////////////////////////////////////////////////////////////
7721 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Stop()
7722 /// @brief \b Function \b Description: stop captrue pcm data from DDR
7723 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7724 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7725 /// @param <RET> \b NONE :
7726 /// @param <GLOBAL> \b NONE :
7727 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)7728 MS_BOOL HAL_AUDIO_PCMCapture_Stop(const AUDIO_DEVICE_TYPE eID)
7729 {
7730 MS_BOOL ret = TRUE;
7731 MS_U8 flagCount = 0;
7732
7733 switch(eID)
7734 {
7735 case E_DEVICE0:
7736 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0); // stop
7737 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0);
7738 do
7739 {
7740 MsOS_DelayTask(2);
7741 flagCount ++;
7742 if (flagCount > 100)
7743 {
7744 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
7745 break;
7746 }
7747 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) > 0);
7748 break;
7749
7750 case E_DEVICE1:
7751 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0); //stop
7752 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0);
7753 do
7754 {
7755 MsOS_DelayTask(2);
7756 flagCount ++;
7757 if (flagCount > 100)
7758 {
7759 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Stop : Device%d timeout =======", eID);
7760 break;
7761 }
7762 } while (HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) > 0);
7763 break;
7764
7765 default:
7766 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Stop : unsupported DEVICE TYPE!!!=======");
7767 ret = FALSE;
7768 break;
7769 }
7770
7771 return ret;
7772 }
7773
7774
7775 ////////////////////////////////////////////////////////////////////////////////
7776 /// @brief \b Function \b Name: HAL_AUDIO_PCMCapture_Read()
7777 /// @brief \b Function \b Description: captrue pcm data from DDR to device
7778 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7779 /// @param <IN> \b void* : destination buffer pointer
7780 /// @param <IN> \b MS_U32 : buffer size need transfered in byte
7781 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7782 /// @param <RET> \b NONE :
7783 /// @param <GLOBAL> \b NONE :
7784 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID,void * buffer,const MS_U32 bytes)7785 MS_BOOL HAL_AUDIO_PCMCapture_Read(const AUDIO_DEVICE_TYPE eID, void* buffer, const MS_U32 bytes)
7786 {
7787 MS_BOOL ret = TRUE;
7788 MS_VIRT buffer_tmp = (MS_VIRT)buffer;
7789 MS_U32 request_size = bytes;
7790 MS_U32 read_ptr_mailbox = 0;
7791 MS_U32 write_ptr_mailbox = 0;
7792 MS_PHY pcm_capture_base_addr_tmp = 0;
7793 MS_PHY pcm_capture_read_addr_tmp = 0;
7794 MS_PHY pcm_capture_write_addr_tmp = 0;
7795 MS_S32 avail_size = 0;
7796
7797 switch(eID)
7798 {
7799 case E_DEVICE0:
7800 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE_DDR_RdPtr;
7801 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE_DDR_WrPtr;
7802 pcm_capture_base_addr_tmp = g_pcm_capture_base_addr;
7803 break;
7804
7805 case E_DEVICE1:
7806 read_ptr_mailbox = M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr;
7807 write_ptr_mailbox = S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr;
7808 pcm_capture_base_addr_tmp = g_pcm_capture2_base_addr;
7809 break;
7810
7811 default:
7812 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====PCMCapture_Read : unsupported DEVICE TYPE!!!=======\n");
7813 ret = FALSE;
7814 break;
7815 }
7816
7817 if (ret == FALSE)
7818 return ret;
7819
7820 //get read & write pointer
7821 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(read_ptr_mailbox) * BYTES_IN_MIU_LINE);
7822 pcm_capture_write_addr_tmp = pcm_capture_base_addr_tmp + (HAL_AUDIO_ReadReg(write_ptr_mailbox) * BYTES_IN_MIU_LINE);
7823 avail_size = (MS_S32)(pcm_capture_write_addr_tmp - pcm_capture_read_addr_tmp);
7824 if (avail_size < 0)
7825 {
7826 avail_size += (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE);
7827 }
7828
7829 // if overflow , return false
7830 if (avail_size >= ((DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE - DSP2_PCM_CAPTURE_COPY_LINESIZE) * BYTES_IN_MIU_LINE))
7831 {
7832 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n ===== PCM DATA OVERFLOW !!!=======\n");
7833
7834 HAL_AUDIO_PCMCapture_Stop(eID);
7835 HAL_AUDIO_PCMCapture_Start(eID);
7836 ret = FALSE;
7837 return ret;
7838 }
7839
7840 // if no enough data, do nothing.
7841 if (avail_size < request_size)
7842 {
7843 ret = FALSE;
7844 return ret;
7845 }
7846
7847 //copy data to destination.
7848 do
7849 {
7850 MS_U32 size_tmp = (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)) - pcm_capture_read_addr_tmp;
7851
7852 size_tmp = (avail_size >= size_tmp) ? size_tmp : avail_size;
7853 size_tmp = (request_size >= size_tmp) ? size_tmp : request_size;
7854
7855 memcpy((void *)buffer_tmp, (void *)MS_PA2KSEG1(pcm_capture_read_addr_tmp), size_tmp);
7856 MsOS_FlushMemory();
7857
7858 pcm_capture_read_addr_tmp += size_tmp;
7859 if (pcm_capture_read_addr_tmp == (pcm_capture_base_addr_tmp + (DSP2_PCM_CAPTURE_BUFFER_DRAM_SIZE * BYTES_IN_MIU_LINE)))
7860 pcm_capture_read_addr_tmp = pcm_capture_base_addr_tmp;
7861
7862 buffer_tmp += size_tmp;
7863 avail_size -= size_tmp;
7864 request_size -= size_tmp;
7865
7866 } while (request_size > 0);
7867
7868 //update read pointer
7869 HAL_AUDIO_WriteReg(read_ptr_mailbox, ((pcm_capture_read_addr_tmp - pcm_capture_base_addr_tmp) / BYTES_IN_MIU_LINE));
7870
7871 return ret;
7872 }
7873
7874 ////////////////////////////////////////////////////////////////////////////////
7875 /// @brief \b Function \b Name: HAL_AUDIO_SetDataCaptureSource()
7876 /// @brief \b Function \b Description: Select source for data capture
7877 /// @param <IN> \b AUDIO_DEVICE_TYPE : select 1st or 2nd data capture
7878 /// @param <IN> \b AUDIO_CAPTURE_SOURCE_TYPE : Data Source
7879 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
7880 /// @param <RET> \b NONE :
7881 /// @param <GLOBAL> \b NONE :
7882 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID,AUDIO_CAPTURE_SOURCE_TYPE eSource)7883 MS_BOOL HAL_AUDIO_SetDataCaptureSource(AUDIO_DEVICE_TYPE eID, AUDIO_CAPTURE_SOURCE_TYPE eSource)
7884 {
7885 MS_U32 u32ControlAddress;
7886 MS_BOOL ret = TRUE;
7887
7888 HALAUDIO_CHECK_SHM_INIT;
7889
7890 switch(eID)
7891 {
7892 case E_DEVICE0:
7893 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL;
7894 break;
7895
7896 case E_DEVICE1:
7897 u32ControlAddress=M2S_MBOX_CAPTURE_CTRL+1;
7898 break;
7899
7900 default:
7901 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
7902 return FALSE;
7903 }
7904
7905 switch(eSource)
7906 {
7907 case E_CAPTURE_CH5:
7908 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH5);
7909 break;
7910
7911 case E_CAPTURE_CH6:
7912 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH6);
7913 break;
7914
7915 case E_CAPTURE_CH7:
7916 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH7);
7917 break;
7918
7919 case E_CAPTURE_CH8:
7920 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_CH8);
7921 break;
7922
7923 case E_CAPTURE_ADC:
7924 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
7925 break;
7926
7927 case E_CAPTURE_ADC2:
7928 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
7929 break;
7930
7931 case E_CAPTURE_PCM_SE:
7932 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_Raw_Delay_SE);
7933 break;
7934
7935 case E_CAPTURE_MIXER:
7936 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_MIXER);
7937 break;
7938
7939 case E_CAPTURE_ADC1_AUIN0_INPUT:
7940 case E_CAPTURE_ADC1_AUIN1_INPUT:
7941 case E_CAPTURE_ADC1_AUIN2_INPUT:
7942 case E_CAPTURE_ADC1_AUIN3_INPUT:
7943 case E_CAPTURE_ADC1_AUIN4_INPUT:
7944 case E_CAPTURE_ADC1_AUIN5_INPUT:
7945 case E_CAPTURE_ADC1_AUMIC_INPUT:
7946 {
7947 MS_U8 u8temp = 0;
7948
7949 //check if ADC1 is occupied by main or sub channel
7950 if((LONIBBLE(g_AudioVars2->eMainAudioSource) == 2 || LONIBBLE(g_AudioVars2->eSubAudioSource) == 2))
7951 {
7952 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "===The audio capture setting is failed by the following reason:=== \n");
7953 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "The input setting of ADC1 is occupied by main or sub channel\n");
7954 ret = FALSE;
7955 break;
7956 }
7957
7958 //switch source of ADC1
7959 if (eSource == E_CAPTURE_ADC1_AUIN0_INPUT)
7960 {
7961 u8temp = 0x00;
7962 }
7963 else if (eSource == E_CAPTURE_ADC1_AUIN1_INPUT)
7964 {
7965 u8temp = 0x01;
7966 }
7967 else if (eSource == E_CAPTURE_ADC1_AUIN2_INPUT)
7968 {
7969 u8temp = 0x02;
7970 }
7971 else if (eSource == E_CAPTURE_ADC1_AUIN3_INPUT)
7972 {
7973 u8temp = 0x03;
7974 }
7975 else if (eSource == E_CAPTURE_ADC1_AUIN4_INPUT)
7976 {
7977 u8temp = 0x04;
7978 }
7979 else if (eSource == E_CAPTURE_ADC1_AUIN5_INPUT)
7980 {
7981 u8temp = 0x05;
7982 }
7983 else if (eSource == E_CAPTURE_ADC1_AUMIC_INPUT)
7984 {
7985 u8temp = 0x07;
7986 }
7987
7988 HAL_AUDIO_WriteMaskByte(0x2CE2, 0xF0, (u8temp<<4));
7989 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC1);
7990 break;
7991 }
7992
7993 case E_CAPTURE_ADC2_AUIN0_INPUT:
7994 case E_CAPTURE_ADC2_AUIN1_INPUT:
7995 case E_CAPTURE_ADC2_AUIN2_INPUT:
7996 case E_CAPTURE_ADC2_AUIN3_INPUT:
7997 case E_CAPTURE_ADC2_AUIN4_INPUT:
7998 case E_CAPTURE_ADC2_AUIN5_INPUT:
7999 case E_CAPTURE_ADC2_AUMIC_INPUT:
8000 {
8001 MS_U8 u8temp = 0;
8002
8003 //check if ADC2 is occupied by main or sub channel
8004 if((LONIBBLE(g_AudioVars2->eMainAudioSource) == 9 || LONIBBLE(g_AudioVars2->eSubAudioSource) == 9))
8005 {
8006 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "===The audio capture setting is faiedl by the following reason:=== \n");
8007 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "The input setting of ADC2 is occupied by main or sub channel \n");
8008 ret = FALSE;
8009 break;
8010 }
8011
8012 //switch source of ADC2
8013 if (eSource == E_CAPTURE_ADC2_AUIN0_INPUT)
8014 {
8015 u8temp = 0x00;
8016 }
8017 else if (eSource == E_CAPTURE_ADC2_AUIN1_INPUT)
8018 {
8019 u8temp = 0x01;
8020 }
8021 else if (eSource == E_CAPTURE_ADC2_AUIN2_INPUT)
8022 {
8023 u8temp = 0x02;
8024 }
8025 else if (eSource == E_CAPTURE_ADC2_AUIN3_INPUT)
8026 {
8027 u8temp = 0x03;
8028 }
8029 else if (eSource == E_CAPTURE_ADC2_AUIN4_INPUT)
8030 {
8031 u8temp = 0x04;
8032 }
8033 else if (eSource == E_CAPTURE_ADC2_AUIN5_INPUT)
8034 {
8035 u8temp = 0x05;
8036 }
8037 else if (eSource == E_CAPTURE_ADC2_AUMIC_INPUT)
8038 {
8039 u8temp = 0x07;
8040 }
8041 HAL_AUDIO_WriteMaskByte(0x2CE2, 0x0F, u8temp);
8042 HAL_AUDIO_WriteByte(u32ControlAddress, M2S_MBOX_GET_ADC2);
8043 break;
8044 }
8045
8046 default:
8047 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "\r\n =====SetDataCaptureSource : unsupport DEVICE TYPE!!!=======");
8048 ret = FALSE;
8049 break;
8050 }
8051
8052 return ret;
8053 }
8054
_AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)8055 MS_BOOL _AudioReloadCodePreProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
8056 {
8057 MS_U16 time_out;
8058
8059 code_type = code_type;
8060 if ( eDspId >= AUDIO_DSP_ID_R2 )
8061 {
8062 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
8063 return FALSE;
8064 }
8065
8066 if ( eDspId == AUDIO_DSP_ID_SND )
8067 {
8068 Dvb2DecCmd_tmp = HAL_AUDIO_Se_Status();
8069 HAL_MAD_SetDSP2DecCmd(AU_DVB_DECCMD_STOP); // Stop
8070
8071 MsOS_DisableInterrupt(E_INT_FIQ_DEC_DSP2UP);
8072
8073 // Reset MAD module
8074 HAL_MAD2_DisEn_MIUREQ();
8075
8076 HAL_MAD2_SetDspIDMA();
8077 // Enter MCU/DSP hand-shake
8078 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_BEG >> 8);
8079
8080 // PIO[8] interrupt
8081 HAL_MAD2_TriggerPIO8();
8082
8083 //Wait Dsp Start reload Ack
8084 time_out = 0;
8085 while ( time_out++ < 2000 )
8086 {
8087 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK1 )
8088 {
8089 break;
8090 }
8091
8092 AUDIO_DELAY1MS(1);
8093 }
8094
8095 if ( time_out >= 2000 )
8096 {
8097 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, " SND DSP Reload timeOut1: %d\r\n", time_out);
8098 return FALSE;
8099 }
8100
8101 // Change to IDMA Port
8102 HAL_MAD2_SetDspIDMA();
8103 }
8104
8105 return TRUE;
8106 }
8107
_AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId,AUDIO_DSP_CODE_TYPE code_type)8108 MS_BOOL _AudioReloadCodePostProcess(AUDIO_DSP_ID eDspId, AUDIO_DSP_CODE_TYPE code_type)
8109 {
8110 MS_U16 time_out;
8111
8112 code_type = code_type;
8113
8114 if ( eDspId >= AUDIO_DSP_ID_R2 )
8115 {
8116 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: invalid DSP ID (%d) !!\r\n", __FUNCTION__, eDspId);
8117 return FALSE;
8118 }
8119
8120 if ( eDspId == AUDIO_DSP_ID_SND )
8121 {
8122 // Enter MCU/DSP hand-shake
8123 HAL_MAD2_SetMcuCmd(MBOX_DBGCMD_RELOAD_SIF_END >> 8);
8124
8125 HAL_MAD2_TriggerPIO8();
8126
8127 // Wait Dsp End Reload Ack
8128 time_out = 0;
8129 while ( time_out++ < 3000 )
8130 {
8131 if ( HAL_MAD2_GetReloadCodeAck() == MBOX_DSP_RELOAD_ACK2 )
8132 {
8133 break;
8134 }
8135
8136 AUDIO_DELAY1MS(1);
8137 }
8138
8139 if ( time_out >= 3000 )
8140 {
8141 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, " SND DSP Reload timeOut2\r\n");
8142 return FALSE;
8143 }
8144
8145 HAL_MAD2_SetMcuCmd(0x00); // In T3, clear 0x2DDC after reload finish
8146
8147 MsOS_EnableInterrupt(E_INT_FIQ_DEC_DSP2UP);
8148 HAL_MAD_SetDSP2DecCmd((AU_DVB_DECCMD) Dvb2DecCmd_tmp);
8149 }
8150
8151 return TRUE;
8152 }
8153
HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id,AUDIO_DSP_CODE_TYPE code_type,void * pau_info)8154 MS_BOOL HAL_AUDIO_AlgReloadCode2(AUDIO_DSP_ID id, AUDIO_DSP_CODE_TYPE code_type, void * pau_info)
8155 {
8156 if ( _AudioReloadCodePreProcess(id, code_type) == FALSE )
8157 {
8158 return FALSE;
8159 }
8160
8161 // Start to Reload DSP code
8162 if ( HAL_AUDSP_DspLoadCode2((MS_U8) id, pau_info) == FALSE )
8163 {
8164 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, " %s DSP Reload Fail !!\r\n", (id==AUDIO_DSP_ID_DEC ? "DEC" : "SND"));
8165 return FALSE;
8166 }
8167
8168 if ( _AudioReloadCodePostProcess(id, code_type) == FALSE )
8169 {
8170 return FALSE;
8171 }
8172
8173 return TRUE;
8174 }
8175
HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId,En_DVB_decSystemType Param)8176 MS_BOOL HAL_AUDIO_SetSystem2(AUDIO_DEC_ID DecId, En_DVB_decSystemType Param)
8177 {
8178 MS_U32 regDecoderType = REG_R2_DECODE1_TYPE;
8179 MS_BOOL bRet = TRUE;
8180
8181 if(DecId == AU_DEC_ID3)
8182 {
8183 regDecoderType = REG_R2_DECODE2_TYPE;
8184 }
8185 else if (DecId == AU_DEC_ID1)
8186 {
8187 regDecoderType = REG_R2_DECODE1_TYPE;
8188 }
8189 else if (DecId == AU_DEC_ID2)
8190 {
8191 // AU_DEC_ID2 only for ATV SIF
8192 // For other case should not use AU_DEC_ID2
8193 return bRet;
8194 }
8195
8196 switch (Param)
8197 {
8198 case MSAPI_AUD_DVB_MPEG:
8199 case MSAPI_AUD_DVB_MP3:
8200 HAL_AUR2_WriteByte(regDecoderType, adec_type_mpeg);
8201 if (DecId == AU_DEC_ID3)
8202 {
8203 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_MPEG, TRUE);
8204 }
8205 else
8206 {
8207 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_MPEG, TRUE);
8208 }
8209 break;
8210
8211 case MSAPI_AUD_DVB_MS10_DDC:
8212 case MSAPI_AUD_DVB_AC3P:
8213 case MSAPI_AUD_DVB_AC3:
8214 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
8215 HAL_AUR2_WriteByte(regDecoderType, adec_type_ac3);
8216 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
8217 if (DecId == AU_DEC_ID3)
8218 {
8219 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AC3P, TRUE);
8220 }
8221 else
8222 {
8223 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AC3P, TRUE);
8224 }
8225 break;
8226
8227 case MSAPI_AUD_DVB_AAC:
8228 case MSAPI_AUD_DVB_MS10_DDT:
8229 if (g_AudioVars2->DolbyAACFlag == 1)
8230 {
8231 HAL_AUR2_WriteByte(regDecoderType, adec_type_aac);
8232 }
8233 else
8234 {
8235 HAL_AUR2_WriteByte(regDecoderType, adec_type_gaac);
8236 }
8237 HAL_MAD2_ReLoadCode(AU_DVB2_ENCODE_MS10_DDE);
8238 if (DecId == AU_DEC_ID3)
8239 {
8240 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_AAC, TRUE);
8241 }
8242 else
8243 {
8244 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_AAC, TRUE);
8245 }
8246 break;
8247
8248 case MSAPI_AUD_DVB_XPCM:
8249 HAL_AUR2_WriteByte(regDecoderType, adec_type_xpcm);
8250 if (DecId == AU_DEC_ID3)
8251 {
8252 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_XPCM, TRUE);
8253 }
8254 else
8255 {
8256 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_XPCM, TRUE);
8257 }
8258 break;
8259
8260 case MSAPI_AUD_DVB_RA8LBR:
8261 HAL_AUR2_WriteByte(regDecoderType, adec_type_ra8);
8262 if (DecId == AU_DEC_ID3)
8263 {
8264 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
8265 }
8266 else
8267 {
8268 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_RA8LBR, TRUE);
8269 }
8270 break;
8271
8272 case MSAPI_AUD_DVB_WMA:
8273 HAL_AUR2_WriteByte(regDecoderType, adec_type_wma);
8274 if (DecId == AU_DEC_ID3)
8275 {
8276 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA, TRUE);
8277 }
8278 else
8279 {
8280 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA, TRUE);
8281 }
8282 break;
8283
8284 case MSAPI_AUD_DVB_DTS:
8285 case MSAPI_AUD_DVB_DTSLBR:
8286 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
8287 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
8288 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
8289 if (DecId == AU_DEC_ID3)
8290 {
8291 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
8292 }
8293 else
8294 {
8295 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
8296 }
8297 break;
8298
8299 case MSAPI_AUD_DVB_WMA_PRO:
8300 HAL_AUR2_WriteByte(regDecoderType, adec_type_wmap);
8301 if (DecId == AU_DEC_ID3)
8302 {
8303 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
8304 }
8305 else
8306 {
8307 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_WMA_PRO, TRUE);
8308 }
8309 break;
8310
8311 case MSAPI_AUD_DVB_DRA:
8312 HAL_AUR2_WriteByte(regDecoderType, adec_type_dra);
8313 if (DecId == AU_DEC_ID3)
8314 {
8315 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DRA, TRUE);
8316 }
8317 else
8318 {
8319 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DRA, TRUE);
8320 }
8321 break;
8322
8323 case MSAPI_AUD_DVB_FLAC:
8324 HAL_AUR2_WriteByte(regDecoderType, adec_type_flac);
8325 if (DecId == AU_DEC_ID3)
8326 {
8327 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_FLAC, TRUE);
8328 }
8329 else
8330 {
8331 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_FLAC, TRUE);
8332 }
8333 break;
8334
8335 case MSAPI_AUD_DVB_VORBIS:
8336 HAL_AUR2_WriteByte(regDecoderType, adec_type_vorbis);
8337 if (DecId == AU_DEC_ID3)
8338 {
8339 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_VORBIS, TRUE);
8340 }
8341 else
8342 {
8343 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_VORBIS, TRUE);
8344 }
8345 break;
8346
8347 case MSAPI_AUD_DVB_AMR_NB:
8348 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
8349 if (DecId == AU_DEC_ID3)
8350 {
8351 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
8352 }
8353 else
8354 {
8355 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
8356 }
8357 break;
8358
8359 case MSAPI_AUD_DVB_AMR_WB:
8360 HAL_AUR2_WriteByte(regDecoderType, adec_type_dummy);
8361 if (DecId == AU_DEC_ID3)
8362 {
8363 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_INVALID, TRUE);
8364 }
8365 else
8366 {
8367 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_INVALID, TRUE);
8368 }
8369 break;
8370
8371 case MSAPI_AUD_DVB_DTSHDADO:
8372 HAL_AUDIO_WriteMaskByte(0x2E8C, 0xFF, 0x00); // disable R2 encode (R2 DDCO)
8373 HAL_AUR2_WriteByte(regDecoderType, adec_type_dts);
8374 HAL_MAD_SetCommInfo(Audio_Comm_infoType_setBypassSPDIF_PAPB_chk, TRUE, 0);
8375 if(DecId == AU_DEC_ID3)
8376 {
8377 HAL_AUDIO_SetDsp2CodeType(AU_DVB_STANDARD_DTS, TRUE);
8378 }
8379 else
8380 {
8381 HAL_AUDIO_SetDspCodeType(AU_DVB_STANDARD_DTS, TRUE);
8382 }
8383 break;
8384
8385 default:
8386 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, Param);
8387 break;
8388 }
8389 return bRet;
8390 }
8391
AU_GetDecID(AUDIO_DEC_ID * DecPriority,AudioDecStatus_t * p_AudioDecStatus)8392 AUDIO_DEC_ID AU_GetDecID(AUDIO_DEC_ID *DecPriority, AudioDecStatus_t * p_AudioDecStatus)
8393 {
8394 MS_U8 Index = 0;
8395 AUDIO_DEC_ID DecID = AU_DEC_INVALID;
8396
8397 for(Index=0; Index<AU_DEC_MAX; Index++)
8398 {
8399 // Get Dec ID by priority
8400 DecID = DecPriority[Index];
8401 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
8402 if ((HAL_MAD_GetAudioCapability(DecID, p_AudioDecStatus) == TRUE) &&
8403 (g_AudioVars2->AudioDecStatus[DecID].bConnect == FALSE))
8404 {
8405 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
8406 break;
8407 }
8408 }
8409
8410 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DecID = %d %s() %d \n",DecID,__FUNCTION__,__LINE__);
8411 return DecID;
8412 }
8413
HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)8414 AUDIO_DEC_ID HAL_AUDIO_OpenDecodeSystem(AudioDecStatus_t * p_AudioDecStatus)
8415 {
8416 AUDIO_DEC_ID DecRet = AU_DEC_INVALID;
8417
8418 switch (p_AudioDecStatus->eSourceType)
8419 {
8420 case E_AUDIO_INFO_ATV_IN:
8421 DecRet = AU_DEC_ID2;
8422 break;
8423
8424 case E_AUDIO_INFO_HDMI_IN:
8425 DecRet = AU_GetDecID(HDMIDecPriority, p_AudioDecStatus);
8426 break;
8427
8428 case E_AUDIO_INFO_DTV_IN:
8429 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
8430 break;
8431
8432 case E_AUDIO_INFO_MM_IN:
8433 case E_AUDIO_INFO_GAME_IN:
8434 if (p_AudioDecStatus->eMMType == AUDIO_MM_VD)
8435 {
8436 DecRet = AU_GetDecID(VDDecPriority, p_AudioDecStatus);
8437 }
8438 else
8439 {
8440 DecRet = AU_GetDecID(MMDecPriority, p_AudioDecStatus);
8441 }
8442 break;
8443
8444 default:
8445 DecRet = AU_GetDecID(DTVDecPriority, p_AudioDecStatus);
8446 break;
8447 }
8448
8449 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DecID = %d %s() %d \n",DecRet,__FUNCTION__,__LINE__);
8450 return DecRet;
8451 }
8452
HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId,AudioDecStatus_t * p_AudioDecStatus)8453 MS_BOOL HAL_AUDIO_SetDecodeSystem(AUDIO_DEC_ID DecId, AudioDecStatus_t *p_AudioDecStatus)
8454 {
8455 AUDIO_DSP_ID DSP_id = AUDIO_DSP_ID_ALL;
8456 MS_S8 MainDecoderId = -1;
8457 MS_BOOL bRet = FALSE;
8458
8459 HALAUDIO_CHECK_SHM_INIT;
8460
8461 if ((g_AudioVars2->AudioDecStatus[DecId].eAudFormat == p_AudioDecStatus->eAudFormat) &&
8462 (g_AudioVars2->AudioDecStatus[DecId].eSourceType == p_AudioDecStatus->eSourceType) &&
8463 (g_AudioVars2->AudioDecStatus[DecId].eGroup == p_AudioDecStatus->eGroup) &&
8464 (g_AudioVars2->AudioDecStatus[DecId].eStcSource == p_AudioDecStatus->eStcSource) &&
8465 (g_AudioVars2->AudioDecStatus[DecId].bIsAD == p_AudioDecStatus->bIsAD))
8466 {
8467 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s() - DSP code is the same\n",__FUNCTION__);
8468 return bRet;
8469 }
8470
8471 // update occupied decoder
8472 if (DecId == AU_DEC_ID3)
8473 {
8474 DSP_id = AUDIO_DSP_ID_SND;
8475 MainDecoderId = 0x1;
8476 }
8477 else if (DecId == AU_DEC_ID1)
8478 {
8479 DSP_id = AUDIO_DSP_ID_DEC;
8480 MainDecoderId = 0x0;
8481 }
8482
8483 if ((p_AudioDecStatus->eAudFormat & MSAPI_AUD_ATV_NONE) == MSAPI_AUD_ATV_NONE)
8484 {
8485 AUDIO_PATH_TYPE u8SifPath;
8486
8487 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
8488 {
8489 u8SifPath = AUDIO_PATH_6;
8490 }
8491 else
8492 {
8493 u8SifPath = AUDIO_PATH_MAIN;
8494 }
8495 HAL_AUDIO_SetInputPath(AUDIO_DSP4_SIF_INPUT , u8SifPath);
8496 }
8497 else
8498 {
8499 HAL_MAD_DvbFLockSynthesizer_En();
8500 if (MainDecoderId != -1)
8501 {
8502 if (p_AudioDecStatus->eGroup == E_CONNECT_SUB)
8503 {
8504 /*
8505 * if it's sub case, then the other decoder is main decoder
8506 * sub is dec1, then main is dec2
8507 * sub is dec2, then main is dec1
8508 */
8509 MainDecoderId = (MainDecoderId == 0x1) ? 0x0 : 0x1;
8510 }
8511 // Inform R2 main decoder, 0:dec 1 , 1:dec2
8512 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_MAIN_SEL, 0x01, MainDecoderId);
8513 }
8514 }
8515 g_AudioVars2->AudioDecStatus[DecId].eDSPId = DSP_id;
8516 p_AudioDecStatus->eDSPId = DSP_id;
8517
8518 switch ( p_AudioDecStatus->eAudFormat)
8519 {
8520 case MSAPI_AUD_DVB_MPEG:
8521 case MSAPI_AUD_DVB_AC3:
8522 case MSAPI_AUD_DVB_AC3P:
8523 case MSAPI_AUD_DVB_MP3:
8524 case MSAPI_AUD_DVB_AAC:
8525 case MSAPI_AUD_DVB_XPCM:
8526 case MSAPI_AUD_DVB_RA8LBR:
8527 case MSAPI_AUD_DVB_WMA:
8528 case MSAPI_AUD_DVB_DTS:
8529 case MSAPI_AUD_DVB_DTSLBR:
8530 case MSAPI_AUD_DVB_DTSHDADO:
8531 case MSAPI_AUD_DVB_MS10_DDT:
8532 case MSAPI_AUD_DVB_MS10_DDC:
8533 case MSAPI_AUD_DVB_WMA_PRO:
8534 case MSAPI_AUD_DVB_FLAC:
8535 case MSAPI_AUD_DVB_VORBIS:
8536 case MSAPI_AUD_DVB_AMR_NB:
8537 case MSAPI_AUD_DVB_AMR_WB:
8538 case MSAPI_AUD_DVB_DRA:
8539 bRet = HAL_AUDIO_SetSystem2(DecId, p_AudioDecStatus->eAudFormat);
8540 break;
8541
8542 case MSAPI_AUD_ATV_BTSC:
8543 bRet = HAL_SIF_SetSystem(AU_SIF_BTSC);
8544 break;
8545
8546 case MSAPI_AUD_ATV_PAL:
8547 bRet = HAL_SIF_SetSystem(AU_SIF_PALSUM);
8548 break;
8549
8550 case MSAPI_AUD_ATV_EIAJ:
8551 case MSAPI_AUD_ATV_FM_RADIO:
8552 break;
8553
8554 default:
8555 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: UN-KNOW DECODER TYPE (0x%x) !!\r\n", __FUNCTION__, p_AudioDecStatus->eAudFormat);
8556 break;
8557 }
8558
8559 return bRet;
8560 }
8561
8562 ////////////////////////////////////////////////////////////////////////////////
8563 /// @brief \b Function \b Name: HAL_AUDIO_GetDDRInfo()
8564 /// @brief \b Function \b Description: Return Audio DDR info
8565 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
8566 /// @param <IN> \b EN_AUDIO_DDRINFO : DDR info
8567 /// @param <OUT> \b MS_U32 : return DDR info
8568 /// @param <RET> \b NONE :
8569 /// @param <GLOBAL> \b NONE :
8570 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId,EN_AUDIO_DDRINFO DDRInfo)8571 MS_PHY HAL_AUDIO_GetDDRInfo(AUDIO_DEC_ID DecId, EN_AUDIO_DDRINFO DDRInfo)
8572 {
8573 MS_PHY DDR_ADDR = 0;
8574 MS_PHY DDR_ADDR_LINE_BASE = 0;
8575 MS_PHY DDR_ADDR_TMP;
8576 MS_PHY DDR_Value = 0;
8577 if (DecId == AU_DEC_ID1)
8578 {
8579 switch(DDRInfo)
8580 {
8581 case E_AUD_MEMORY_BASE: //use DSP2 base instead
8582 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
8583 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
8584 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
8585 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
8586 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
8587 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
8588 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
8589 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
8590 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
8591 DDR_Value = DDR_ADDR;
8592 break;
8593 case E_AUD_MEMORY_SIZE:
8594 //TODO
8595 break;
8596 default:
8597 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
8598 break;
8599 }
8600 }
8601 else if(DecId == AU_DEC_ID3)
8602 {
8603 switch(DDRInfo)
8604 {
8605 case E_AUD_MEMORY_BASE:
8606 DDR_ADDR_TMP = HAL_AUDIO_ReadByte((REG_SE_MAD_OFFSET_BASE_L + 1)); // [7:0]
8607 DDR_ADDR_LINE_BASE = DDR_ADDR_TMP & 0xFF;
8608 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_H); // [23:8]
8609 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xFFFF;
8610 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<8);
8611 DDR_ADDR_TMP = HAL_AUDIO_ReadReg(REG_SE_MAD_OFFSET_BASE_EXT); // [27:24]
8612 DDR_ADDR_TMP = DDR_ADDR_TMP & 0xF;
8613 DDR_ADDR_LINE_BASE = DDR_ADDR_LINE_BASE + (DDR_ADDR_TMP <<24);
8614 DDR_ADDR = DDR_ADDR + (DDR_ADDR_LINE_BASE<<BYTES_IN_MIU_LINE_LOG2);
8615 DDR_Value = DDR_ADDR;
8616 break;
8617 case E_AUD_MEMORY_SIZE:
8618 //TODO
8619 break;
8620 default:
8621 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: UN-KNOW DDRInfo (0x%x) !!\r\n", __FUNCTION__, DDRInfo);
8622 break;
8623 }
8624 }
8625 else
8626 {
8627 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: UN-KNOW DecId (0x%x) !!\r\n", __FUNCTION__, DecId);
8628 }
8629 return DDR_Value;
8630 }
8631
8632 ////////////////////////////////////////////////////////////////////////////////
8633 /// @brief \b Function \b Name: HAL_AUDIO_DumpDspInfo()
8634 /// @brief \b Function \b Description: Dump DSP infomation
8635 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_DumpDspInfo(void)8636 void HAL_AUDIO_DumpDspInfo(void)
8637 {
8638 MS_U32 tmp_H, tmp_L, tmp_M;
8639 MS_U32 result = 0;
8640 MS_U32 ES_Lvl, PCM_Lvl;
8641 static MS_U32 preSysTime, prv_mmFile_APTS;
8642 MS_U32 sysTime, mmFile_APTS;
8643
8644 if (g_AudioDumpInfoCtrl == Audio_DumpInfo_Off)
8645 {
8646 return;
8647 }
8648
8649 ES_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ES_LEVEL, ADEC1);
8650 PCM_Lvl = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PCM_DMX_LEVEL, ADEC1);
8651
8652 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Avsync) != 0)
8653 {
8654 sysTime = MsOS_GetSystemTime();
8655 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[%08u]", (unsigned int)sysTime);
8656
8657 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8658 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "ES=%03X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
8659
8660 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
8661 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
8662 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "PCM=%04X(%04X,%04X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
8663
8664 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8665 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "play=%X", (unsigned int)tmp_L);
8666
8667 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
8668 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "<%04X>,", (unsigned int)tmp_L);
8669
8670 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
8671 tmp_M = HAL_DEC_R2_Get_SHM_PARAM(R2_SHM_PARAM_MM_TS_SYNC_STC, 0, 0)&0x0F;
8672 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
8673 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "State=%X,%X(%X)|", (unsigned int)tmp_L,(unsigned int)tmp_M, (unsigned int)tmp_H);
8674
8675 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8676 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8677 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "frmCnt:%04X,", (unsigned int)tmp_L);
8678 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%04X,", (unsigned int)tmp_H);
8679
8680 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8681 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8682 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,", (unsigned int)tmp_L);
8683 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,", (unsigned int)tmp_H);
8684
8685 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_1STPTS_CNT, ADEC1)&0x00FF;
8686 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_WAIT_STC_CNT, ADEC1)&0x00FF;
8687 tmp_M = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_FLUSH_CNT, ADEC1)&0x00FF;
8688 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,%02X,%02X|", (unsigned int)tmp_L, (unsigned int)tmp_H, (unsigned int)tmp_M);
8689
8690 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_WR_IDX, ADEC1)&0xF;
8691 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS_TAG_RD_IDX, ADEC1)&0xF;
8692 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "tag:%01X,%01X|", (unsigned int)tmp_L, (unsigned int)tmp_H);
8693
8694 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_OFFSET, ADEC1)&0x00FFFFFF;
8695 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "AvDly=%05X,", (unsigned int)tmp_L);
8696
8697 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_STC, ADEC1);
8698 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "STC=%d,", (unsigned int)result/45);
8699
8700 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PTS, ADEC1);
8701 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "PTS=%d,", (unsigned int)result/45);
8702
8703 result = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_CURR_PTS, ADEC1);
8704 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "cPTS=%d,", (unsigned int)result/45);
8705
8706 result = HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_33bit_STCPTS_DIFF);
8707 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "|Td=%x\n", (unsigned int)result/90);
8708 }
8709
8710 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_Dec1) != 0)
8711 {
8712 sysTime = MsOS_GetSystemTime();
8713 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[%08u]", (unsigned int)sysTime);
8714
8715 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8716 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "ES=%03X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
8717
8718 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFF;
8719 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
8720 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "PCM=%04X(%04X,%02X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
8721
8722 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_TYPE);
8723 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "ID=%02X,", (unsigned int)tmp_L);
8724
8725 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_TYPE, ADEC1)&0x00FF;
8726 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Type=%02X,", (unsigned int)tmp_L);
8727
8728 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFFFF;
8729 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "pState=%06X,", (unsigned int)tmp_L);
8730
8731 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
8732 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
8733 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "|Cmd=%02X,Stop=%02X|", (unsigned int)tmp_L, (unsigned int)tmp_H);
8734
8735 tmp_L = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER1_CFG);
8736 tmp_H = HAL_AUDIO_ReadReg(REG_AUDIO_DECODER2_CFG);
8737 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Input_Mux:%02X,", (unsigned int)tmp_L&0x7);
8738 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,", (unsigned int)tmp_H&0x7);
8739 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X|", (unsigned int)(tmp_L>>16)&0x7);
8740
8741 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8742 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8743 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "frmCnt:%04X,", (unsigned int)tmp_L);
8744 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%04X,", (unsigned int)tmp_H);
8745
8746 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8747 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8748 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,", (unsigned int)tmp_L);
8749 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X|", (unsigned int)tmp_H);
8750
8751 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FFFF;
8752 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x0000FFFF;
8753 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Call:%04X,", (unsigned int)tmp_L);
8754 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "sMiss:%04X|", (unsigned int)tmp_H);
8755
8756 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
8757 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "pcm=%06X,", (unsigned int)tmp_L); //need get from DSP
8758
8759 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_R, DSP_MEM_TYPE_DM)&0x00FFFFFF;
8760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%06X|", (unsigned int)tmp_L); //need get from DSP
8761
8762 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8763 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "play=%X\n", (unsigned int)tmp_L);
8764 }
8765
8766
8767 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_IoInfo) != 0)
8768 {
8769 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH5_CFG)) & 0x000F;
8770 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "CH5 mux=0x%02X,", (unsigned int)tmp_L);
8771
8772 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH6_CFG)) & 0x000F;
8773 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Ch6 mux=0x%02X,", (unsigned int)tmp_L);
8774
8775 tmp_L = (HAL_AUDIO_ReadByte(REG_AUDIO_CH7_CFG)) & 0x000F;
8776 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Ch7 mux=0x%02X", (unsigned int)tmp_L);
8777
8778 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
8779 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "|DEC1=0x%06X,", (unsigned int)tmp_L); //need get from DSP
8780
8781 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+R2_SHM_INFO_DEC_OUT_L, DSP_MEM_TYPE_DM)&0x00FFFFFF;
8782 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DEC2=0x%06X", (unsigned int)tmp_L); //need get from DSP
8783
8784 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_RAW+0, DSP_MEM_TYPE_DM);
8785 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "|CH5=0x%06X,", (unsigned int)tmp_L);
8786
8787 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_MUL_CH6+0, DSP_MEM_TYPE_DM);
8788 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "CH6=0x%06X,", (unsigned int)tmp_L);
8789
8790 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info2+IO_INFO2_SCART+0, DSP_MEM_TYPE_DM);
8791 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "CH7=0x%06X", (unsigned int)tmp_L);
8792
8793 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_DAC1_OUT+0, DSP_MEM_TYPE_DM);
8794 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "|DAC1=0x%06X,", (unsigned int)tmp_L);
8795
8796 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_IIS1_OUT+0, DSP_MEM_TYPE_DM);
8797 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "I2S=0x%06X,", (unsigned int)tmp_L);
8798
8799 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_IO_Info1+IO_INFO1_SPDIF_OUT+0, DSP_MEM_TYPE_DM);
8800 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "SPDIF=0x%06X\n", (unsigned int)tmp_L);
8801 }
8802
8803 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_AutoTest) != 0)
8804 {
8805 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x00FFFFFF;
8806 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x00FFFFFF;
8807 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[AutoTest][AUDIO][FrameCount][%d]\n", (unsigned int)tmp_L);
8808 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[AutoTest][AUDIO][ErrorCount][%d]\n", (unsigned int)tmp_H);
8809
8810 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SMP_RATE, ADEC1);
8811 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[AutoTest][AUDIO][SampleRate][%d]\n", (unsigned int)tmp_L);
8812 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CHANNEL_MODE, ADEC1);
8813 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[AutoTest][AUDIO][ACMod][%d]\n", (unsigned int)tmp_L);
8814 }
8815
8816 if ((g_AudioDumpInfoCtrl & Audio_DumpInfo_mmFileAVsync) != 0)
8817 {
8818 sysTime = MsOS_GetSystemTime();
8819 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "[%08u](%03u):", (unsigned int)sysTime, (unsigned int)(sysTime - preSysTime));
8820 preSysTime = sysTime;
8821
8822 mmFile_APTS = HAL_MAD_GetCommInfo(Audio_Comm_infoType_1ms_PTS);
8823 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "APTS:%07u(%03u)|", (unsigned int)mmFile_APTS, (unsigned int)(mmFile_APTS - prv_mmFile_APTS));
8824 prv_mmFile_APTS = mmFile_APTS;
8825
8826 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_MM_FILE_REQ_SIZE, ADEC1)&0xFFFF;
8827 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "MM:%04X|", (unsigned int)tmp_H);
8828
8829 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ACCUM_ES_BYTECNT, ADEC1)&0xFFFF;
8830 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "ES=%04X(%04X),", (unsigned int)ES_Lvl, (unsigned int)tmp_L);
8831
8832 tmp_L = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_PCMISR_EMPTY_CNT, DSP_MEM_TYPE_DM)&0xFF;
8833 tmp_H = HAL_MAD2_Read_DSP_sram(DSP2DmAddr_r2_pcm1_info+R2_SHM_INFO_ELAPSED_PCM_CNT, DSP_MEM_TYPE_DM)&0xFFFF;
8834 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "PCM=%04X(%06X,%02X)|", (unsigned int)PCM_Lvl, (unsigned int)tmp_H, (unsigned int)tmp_L); //need get from DSP
8835
8836 tmp_L = (MS_U32)HAL_AUR2_ReadByte(REG_R2_DECODE1_CMD);
8837 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_RECEIVE_STOP_CNT, ADEC1)&0x00FF;
8838 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Cmd=%02X,Stop=%02X,", (unsigned int)tmp_L, (unsigned int)tmp_H);
8839
8840 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAYSMPFLAG, ADEC1)&0x1;
8841 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "play=%X", (unsigned int)tmp_L);
8842
8843 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNTH_RATE, ADEC1)&0xFFFF;
8844 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "<%04X>,", (unsigned int)tmp_L);
8845
8846 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_STATE, ADEC1)&0x0F;
8847 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_AVSYNC_FREERUN_TYPE, ADEC1)&0x0F;
8848 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "State=%X(%X)|", (unsigned int)tmp_L, (unsigned int)tmp_H);
8849
8850 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_OK_FRMCNT, ADEC1)&0x0000FFFF;
8851 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_ERR_FRMCNT, ADEC1)&0x0000FFFF;
8852 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "frmCnt:%04X,", (unsigned int)tmp_L);
8853 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%04X,", (unsigned int)tmp_H);
8854
8855 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SKIP_FRMCNT, ADEC1)&0x0000FF;
8856 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_REPT_FRMCNT, ADEC1)&0x0000FF;
8857 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X,", (unsigned int)tmp_L);
8858 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%02X|", (unsigned int)tmp_H);
8859
8860 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_ID, DSP_MEM_TYPE_DM)&0x00FF;
8861 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "DEC_ID=%02X,", tmp_L);
8862
8863 //tmp_L = HAL_MAD_Read_DSP_sram(DSP1DmAddr_sys_DecStatus+SYS_DECSTATUS_DEC_TYPE, DSP_MEM_TYPE_DM)&0x00FF;
8864 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Type=%02X,", tmp_L);
8865
8866 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_PLAY_STATE, ADEC1)&0x00FFFF;
8867 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "pState=%04X,", (unsigned int)tmp_L);
8868
8869 tmp_L = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_DEC_CALLING_CNT, ADEC1)&0x0000FF;
8870 tmp_H = HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SYNC_MISS_CNT, ADEC1)&0x00000FFF;
8871 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Call:%02X,", (unsigned int)tmp_L);
8872 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Miss:%03X\n", (unsigned int)tmp_H);
8873 }
8874
8875 }
8876
8877
8878 #ifndef MSOS_TYPE_NUTTX
HAL_AUDIO_ResetTeeInfoShmToDefault(void)8879 MS_BOOL HAL_AUDIO_ResetTeeInfoShmToDefault(void)
8880 {
8881 if (pAudioTeeInfoShm == NULL)
8882 {
8883 return FALSE;
8884 }
8885 memset(pAudioTeeInfoShm, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
8886 audio_tee_enabled = g_bAudioTeeEnabled;
8887 audio_tee_mbx_initialized = g_bAudioTeeMbxInitialized;
8888 dec_dsp_secure_tee_accessed = g_bDecDspSecureTeeAccessed;
8889 snd_dsp_secure_tee_accessed = g_bSndDspSecureTeeAccessed;
8890 return TRUE;
8891 }
8892
HAL_AUDIO_AllocateTeeInfoShm(void)8893 AUDIO_TEE_INFO_SHARE_MEM *HAL_AUDIO_AllocateTeeInfoShm(void)
8894 {
8895 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
8896 MS_U32 u32ShmId = 0;
8897 AUDIO_TEE_INFO_SHARE_MEM *virtAddr = 0;
8898 MS_U32 u32BufSize = 0;
8899
8900 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)
8901 {
8902 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
8903
8904 if (pAudioTeeInfoShm->g_u32ClientCounter == 0)
8905 {
8906 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "reset Audio TEE Info SHM data ...\n");
8907 HAL_AUDIO_ResetTeeInfoShmToDefault();
8908 }
8909 }
8910 else
8911 {
8912 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)
8913 {
8914 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Audio TEE Info SHM is created...\n");
8915 pAudioTeeInfoShm = (AUDIO_TEE_INFO_SHARE_MEM *) virtAddr;
8916
8917 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "reset Audio TEE Info SHM data ...\n");
8918 HAL_AUDIO_ResetTeeInfoShmToDefault();
8919 }
8920 else
8921 {
8922 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "SHM allocation for Audio TEE Info failed!\n");
8923 return NULL;
8924 }
8925 }
8926
8927 if (g_bAudioTeeInfoShmInitFlag == FALSE)
8928 {
8929 g_bAudioTeeInfoShmInitFlag = TRUE;
8930 pAudioTeeInfoShm->g_u32ClientCounter++;
8931 }
8932 #else
8933 pAudioTeeInfoShm = &gAudioTeeInfoShm;
8934
8935 if (g_bAudioTeeInfoShmInitFlag == FALSE)
8936 {
8937 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Audio TEE Info SHM is created...\n");
8938 g_bAudioTeeInfoShmInitFlag = TRUE;
8939
8940 HAL_AUDIO_ResetTeeInfoShmToDefault();
8941 pAudioTeeInfoShm->g_u32ClientCounter++;
8942 }
8943 #endif
8944 return pAudioTeeInfoShm;
8945 }
8946
HAL_AUDIO_DeAllocateTeeInfoShm(void)8947 MS_BOOL HAL_AUDIO_DeAllocateTeeInfoShm(void)
8948 {
8949 AUDIO_TEE_INFO_SHARE_MEM * pAUDIOShared = NULL;
8950
8951 #if (defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS))
8952 MS_U32 u32ShmId = 0;
8953 MS_VIRT virtAddr = 0;
8954 MS_U32 u32BufSize = 0;
8955
8956 if (g_bAudioTeeInfoShmInitFlag == TRUE)
8957 {
8958 g_bAudioTeeInfoShmInitFlag = FALSE;
8959
8960 if (MsOS_SHM_GetId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, sizeof(AUDIO_TEE_INFO_SHARE_MEM), &u32ShmId, &virtAddr, &u32BufSize, MSOS_SHM_QUERY) == FALSE)
8961 {
8962 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : No AUDIO TEE Info SHM is created!\n", __FUNCTION__);
8963 return FALSE;
8964 }
8965
8966 pAUDIOShared = (AUDIO_TEE_INFO_SHARE_MEM *)virtAddr;
8967 pAUDIOShared->g_u32ClientCounter--;
8968
8969 if (pAUDIOShared->g_u32ClientCounter == 0)
8970 {
8971 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "free Audio TEE Info SHM data ...\n");
8972 #if defined(MSOS_TYPE_LINUX)
8973 if (MsOS_SHM_FreeId((MS_U8 *)AUDIO_TEE_INFO_SHM_NAME, u32ShmId) == TRUE)
8974 {
8975 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "Audio TEE Info SHM data is freed\n");
8976 }
8977 else
8978 {
8979 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s() : AUDIO TEE Info SHM de-allocation failed!\n", __FUNCTION__);
8980 return FALSE;
8981 }
8982 #endif
8983 }
8984 }
8985 #else
8986 pAUDIOShared = &gAudioTeeInfoShm;
8987
8988 if (g_bAudioTeeInfoShmInitFlag == TRUE)
8989 {
8990 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "free Audio TEE Info SHM data ...\n");
8991 g_bAudioTeeInfoShmInitFlag = FALSE;
8992
8993 memset(pAUDIOShared, 0x00, sizeof(AUDIO_TEE_INFO_SHARE_MEM));
8994 }
8995 #endif
8996
8997 return TRUE;
8998 }
8999
HAL_AUDIO_RegisterMBX(void)9000 MS_BOOL HAL_AUDIO_RegisterMBX(void)
9001 {
9002 MS_U8 ClassNum=0;
9003 MBX_Result result;
9004 MBX_CPU_ID eHKCPU;
9005 MS_U32 u32TimeoutMillSecs = 10000;
9006
9007 if (pAudioTeeInfoShm == NULL)
9008 return FALSE;
9009 if (audio_tee_mbx_initialized == TRUE)
9010 return TRUE;
9011
9012 #if 1
9013 eHKCPU = E_MBX_CPU_MIPS;
9014 if ( E_MBX_SUCCESS != MApi_MBX_Init(eHKCPU, E_MBX_ROLE_HK, u32TimeoutMillSecs))
9015 {
9016 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Error> MBX init failed !!\n");
9017 return FALSE;
9018 }
9019 else
9020 {
9021 MApi_MBX_Enable(TRUE);
9022 }
9023 #endif
9024
9025 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass (E_MBX_CPU_MIPS_VPE1, "MAD", (MS_U8 *)&ClassNum))
9026 {
9027 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MAD MApi_MBX_QueryDynamicClass fail\n");
9028
9029 return FALSE;
9030 }
9031 result = MApi_MBX_RegisterMSG(ClassNum, 10);
9032 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
9033 {
9034 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "HAL_AUDIO_RegisterMBX fail");
9035 return FALSE;
9036 }
9037 else
9038 {
9039 TEE_MBX_MSG_CLASS_SET(ClassNum);
9040 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "HAL_AUDIO_RegisterMBX ok");
9041 return TRUE;
9042 }
9043 }
9044
HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)9045 TEE_TO_REE_MBX_ACK_MSG_TYPE HAL_AUDIO_SendMBXMsg(REE_TO_TEE_MBX_MSG_TYPE msg_type)
9046 {
9047 MS_U8 u8Index;
9048 MBX_Result result;
9049 REE_TO_TEE_MBX_MSG_TYPE msg_type1 = REE_TO_TEE_MBX_MSG_NULL;
9050
9051 AUDIO_TEE_INFO_SHM_CHECK_NULL;
9052
9053 if (audio_tee_enabled == FALSE)
9054 {
9055 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
9056 }
9057 if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_DEC) == (REE_TO_TEE_MBX_MSG_TYPE_DEC))
9058 {
9059 if (dec_dsp_secure_tee_accessed == FALSE)
9060 {
9061 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
9062 }
9063 else
9064 {
9065 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_DEC);
9066 }
9067 }
9068 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_SE) == (REE_TO_TEE_MBX_MSG_TYPE_SE))
9069 {
9070 if (snd_dsp_secure_tee_accessed == FALSE)
9071 {
9072 return TEE_TO_REE_MBX_ACK_MSG_NO_TEE;
9073 }
9074 else
9075 {
9076 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_SE);
9077 }
9078 }
9079 else if ((msg_type & REE_TO_TEE_MBX_MSG_TYPE_GENERAL) == (REE_TO_TEE_MBX_MSG_TYPE_GENERAL))
9080 {
9081
9082 msg_type1 = msg_type & (~REE_TO_TEE_MBX_MSG_TYPE_GENERAL);
9083 }
9084
9085 if (audio_tee_mbx_initialized == FALSE)
9086 {
9087 return TEE_TO_REE_MBX_ACK_MSG_INVALID;
9088 }
9089 REE_TO_TEE_MBX_MSG_INIT;
9090 MBX_MSG_SET_CLASSID(ree_to_tee_mbx_msg, tee_mbx_msg_class);
9091 MBX_MSG_SET_CMD(ree_to_tee_mbx_msg, msg_type1);
9092
9093 result = MApi_MBX_SendMsg(&(ree_to_tee_mbx_msg));
9094 if (E_MBX_SUCCESS!= result)
9095 {
9096 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
9097 }
9098 // Receive Reply ACK from TEE side.
9099 memset(&(tee_to_ree_mbx_msg), 0, sizeof(MBX_Msg));
9100 MBX_MSG_SET_CLASSID(tee_to_ree_mbx_msg, tee_mbx_msg_class);
9101 do
9102 {
9103 result = MApi_MBX_RecvMsg(tee_mbx_msg_class, &(tee_to_ree_mbx_msg), 2000, MBX_CHECK_INSTANT_MSG);
9104 } while(E_MBX_SUCCESS != result);
9105
9106 u8Index = tee_to_ree_mbx_msg.u8Index;
9107 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "Recv TEE Ack Msg OK cmd:%x\n", u8Index);
9108
9109 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL == u8Index)
9110 {
9111 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "RecvMsg TEE_TO_REE_MBX_MSG_ACK_FAIL..\n");
9112 return TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
9113 }
9114 if (TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS == u8Index)
9115 {
9116 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "RecvMsg TEE_TO_REE_MBX_MSG_ACK_SUCCESS..\n");
9117 }
9118
9119 return TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
9120 }
9121 #else
_MAD_Proc(void)9122 static void _MAD_Proc(void)
9123 {
9124 MS_U32 u32Events;
9125 MS_U8 u8Index = 0;
9126 MBX_Result result;
9127
9128 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "_MAD_Proc...........\n");
9129
9130 while (1)
9131 {
9132 MsOS_WaitEvent(_s32MadEventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
9133 u8Index = msg.u8Index;
9134
9135 memset(&TeeToReeMbxAckMsg, 0, sizeof(MBX_Msg));
9136 TEE_TO_REE_MBX_MSG_INIT(TeeToReeMbxAckMsg);
9137 MBX_MSG_SET_CLASSID(TeeToReeMbxAckMsg, msg.u8MsgClass);
9138 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS);
9139
9140 switch ( u8Index )
9141 {
9142 case REE_TO_TEE_MBX_MSG_HAL_AUDSP_DspLoadCode:
9143 {
9144 AUDIO_DSP_CODE_TYPE dspCodeType;
9145 dspCodeType = (msg.u8Parameters[0] || (msg.u8Parameters[1] << 8));
9146 if (HAL_AUDSP_DspLoadCode((AUDIO_DSP_CODE_TYPE)dspCodeType) == FALSE)
9147 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
9148 break;
9149 }
9150
9151 case REE_TO_TEE_MBX_MSG_HAL_AUDIO_SetDspBaseAddr:
9152 {
9153 MS_U32 u32Bin_Base_Address, u32Mad_Base_Buffer_Adr;
9154 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));
9155 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));
9156 HAL_AUDIO_SetDspBaseAddr(msg.u8Parameters[0], u32Bin_Base_Address, u32Mad_Base_Buffer_Adr);
9157 break;
9158 }
9159
9160 default:
9161 {
9162 MBX_MSG_SET_CMD(TeeToReeMbxAckMsg, TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL);
9163 break;
9164 }
9165 }
9166
9167 result = MApi_MBX_SendMsg(&TeeToReeMbxAckMsg);
9168 if (E_MBX_SUCCESS != result)
9169 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MAD Reply Ack fail classid: %x cmd:%x \n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
9170 else
9171 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MAD Reply Ack ok classid:%x cmd:%x\n", msg.u8MsgClass, TeeToReeMbxAckMsg.u8Index);
9172 }
9173 }
9174
HAL_AUDIO_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)9175 static void HAL_AUDIO_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
9176 {
9177 if(pMsg==NULL)
9178 {
9179 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "pMsg is a null pointer\n");
9180 return;
9181 }
9182 if (_s32MadEventId < 0)
9183 {
9184 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_DEBUG, "MAD EventGroup Id is not valid...\n");
9185 return;
9186 }
9187 memcpy(&msg, pMsg, sizeof(MBX_Msg));
9188 MsOS_SetEvent(_s32MadEventId, 1);
9189 return;
9190 }
9191 #endif
9192
9193 ////////////////////////////////////////////////////////////////////////////////
9194 /// @brief \b Function \b Name: HAL_AUDIO_update_DspUsage()
9195 /// @brief \b Function \b Description: update DSP resource status when select input source
9196 /// @param <IN> \b AUDIO_SOURCE_INFO_TYPE : select input source type
9197 /// @param <OUT> \b NONE :
9198 /// @param <RET> \b NONE :
9199 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)9200 void HAL_AUDIO_update_DspUsage(AUDIO_SOURCE_INFO_TYPE eSourceType)
9201 {
9202 HALAUDIO_CHECK_SHM_INIT;
9203
9204 /* same input source, not update */
9205 if ( g_AudioVars2->eMainSourceType == eSourceType )
9206 {
9207 return;
9208 }
9209
9210 OS_OBTAIN_MUTEX(_s32MutexLoadCode, MSOS_WAIT_FOREVER);
9211
9212 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: PrevSource %d NowSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType, eSourceType);
9213
9214 /* release prev DSP resource */
9215 if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN && eSourceType != E_AUDIO_INFO_DTV_IN) )
9216 {
9217 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = FALSE;
9218 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
9219 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_NONE;
9220 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Release DEC DSP from DTV !!\r\n", __FUNCTION__);
9221 }
9222 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN && eSourceType != E_AUDIO_INFO_ATV_IN) )
9223 {
9224 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
9225 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
9226 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
9227 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Release SND DSP from ATV !!\r\n", __FUNCTION__);
9228 }
9229 else if ( (g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN && eSourceType != E_AUDIO_INFO_HDMI_IN) )
9230 {
9231 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = FALSE;
9232 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
9233 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_NONE;
9234 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Release SND DSP from HDMI !!\r\n", __FUNCTION__);
9235 }
9236
9237 g_AudioVars2->ePrevSourceType = g_AudioVars2->eMainSourceType;
9238 g_AudioVars2->eMainSourceType = eSourceType;
9239
9240 /* lock main input source DSP resource */
9241 if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_DTV_IN )
9242 {
9243 g_AudioVars2->DspUsage[AU_DEC_ID1].bDecInUsed = TRUE;
9244 g_AudioVars2->DspUsage[AU_DEC_ID1].eAudioType = Audio_DEC_NULL;
9245 g_AudioVars2->DspUsage[AU_DEC_ID1].eUsageType = AUDIO_USAGE_TYPE_DTV;
9246 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Alloc DEC DSP for DTV !!\r\n", __FUNCTION__);
9247 }
9248 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_ATV_IN )
9249 {
9250 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
9251 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
9252 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_ATV;
9253 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Alloc DEC DSP for ATV !!\r\n", __FUNCTION__);
9254 }
9255 else if ( g_AudioVars2->eMainSourceType == E_AUDIO_INFO_HDMI_IN )
9256 {
9257 g_AudioVars2->DspUsage[AU_DEC_ID3].bDecInUsed = TRUE;
9258 g_AudioVars2->DspUsage[AU_DEC_ID3].eAudioType = Audio_DEC_NULL;
9259 g_AudioVars2->DspUsage[AU_DEC_ID3].eUsageType = AUDIO_USAGE_TYPE_HDMI;
9260 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: Alloc DEC DSP for HDMI !!\r\n", __FUNCTION__);
9261 }
9262
9263 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "%s: update PrevSource %d NewSource %d !!\r\n", __FUNCTION__, g_AudioVars2->ePrevSourceType, g_AudioVars2->eMainSourceType);
9264
9265 OS_RELEASE_MUTEX(_s32MutexLoadCode);
9266 }
9267
HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id)9268 Audio_id HAL_AUDIO_Convert_DecId_to_ADECId(AUDIO_DEC_ID dec_id) //temp
9269 {
9270 Audio_id ADEC_id;
9271 switch(dec_id)
9272 {
9273 case AU_DEC_INVALID:
9274 case AU_DEC_MAX:
9275 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "[Error] Can't convert...\n");
9276 ADEC_id = ADEC1; //no usage just take one for it...
9277 break;
9278
9279 case AU_DEC_ID1:
9280 ADEC_id = ADEC1;
9281 break;
9282
9283 case AU_DEC_ID2:
9284 case AU_DEC_ID3:
9285 ADEC_id = ADEC2;
9286 break;
9287
9288 default:
9289 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "[Error] Can't convert...\n");
9290 ADEC_id = ADEC1; //no usage just take one for it...
9291 break;
9292 }
9293 return ADEC_id;
9294 }
9295
9296 ////////////////////////////////////////////////////////////////////////////////
9297 /// @brief \b Function \b Name: HAL_AUDIO_GetCaps()
9298 /// @brief \b Function \b Description: Get Audio Capabilities
9299 /// @param <IN> \b AUDIO_DEC_ID : select audio processor
9300 /// @param <IN> \b MS_U32 * : Audio Capabilites pointer
9301 /// @param <OUT> \b MS_BOOL : return TRUE if success, else return FALSE
9302 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId,MS_U32 * pCaps)9303 MS_U32 HAL_AUDIO_GetCaps(AUDIO_DEC_ID DecId, MS_U32 *pCaps)
9304 {
9305 AUDIO_CAPABILITIES *pCapsTmp = NULL;
9306 MS_U32 u32AudioCapsStructSize = sizeof(AUDIO_CAPABILITIES);
9307
9308 HALAUDIO_CHECK_SHM_INIT;
9309
9310 if (pCaps == NULL)
9311 {
9312 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pCaps should not be NULL!\n", __FUNCTION__);
9313 return FALSE;
9314 }
9315
9316 if ((DecId <= AU_DEC_INVALID) || (DecId >= AU_DEC_MAX) || (DecId == AU_DEC_ID2))
9317 {
9318 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid DecId (%d)!\n", __FUNCTION__, DecId);
9319 return FALSE;
9320 }
9321 else if ((g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum == 1) && (DecId > AU_DEC_ID1))
9322 {
9323 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! DecId (%d) is greater than max decoder number (%d)!\n", __FUNCTION__, DecId, g_AudioVars2->AudioCaps[AU_DEC_ID1].u8MaxDecoderNum);
9324 return FALSE;
9325 }
9326
9327 pCapsTmp = (AUDIO_CAPABILITIES *)pCaps;
9328
9329 if (pCapsTmp->u32AudioCapsVersion == 0)
9330 {
9331 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid version number (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion);
9332 return FALSE;
9333 }
9334
9335 if (pCapsTmp->u32AudioCapsStructSize == 0)
9336 {
9337 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Invalid structure size (%u) from function caller!\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsStructSize);
9338 return FALSE;
9339 }
9340
9341 if (pCapsTmp->u32AudioCapsVersion != g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion)
9342 {
9343 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! function caller's version (%u) is not matched to driver's version (%u) at DecId (%d)\n", __FUNCTION__, (unsigned int)pCapsTmp->u32AudioCapsVersion, (unsigned int)g_AudioVars2->AudioCaps[DecId].u32AudioCapsVersion, DecId);
9344
9345 u32AudioCapsStructSize = (u32AudioCapsStructSize <= pCapsTmp->u32AudioCapsStructSize) ? u32AudioCapsStructSize : pCapsTmp->u32AudioCapsStructSize;
9346 }
9347
9348 memcpy((void *)pCapsTmp, (void *)&g_AudioVars2->AudioCaps[DecId], u32AudioCapsStructSize);
9349
9350 return TRUE;
9351 }
9352
9353 ////////////////////////////////////////////////////////////////////////////////
9354 /// @brief \b Function \b Name: HAL_AUDIO_SET_IPAUTH()
9355 /// @brief \b Function \b Description: HAL_AUDIO_SET_IPAUTH register
9356 /// @param <IN> \b MS_U32 ip_auth
9357 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)9358 void HAL_AUDIO_SET_IPAUTH(MS_U32 ip_auth)
9359 {
9360 if (REG_AUDIO_IPAUTH != 0)
9361 {
9362 HAL_MAD_Write_DSP_sram(REG_AUDIO_IPAUTH, ip_auth, DSP_MEM_TYPE_PM);
9363 }
9364 else
9365 {
9366 HAL_MAD2_Write_DSP_sram(REG_DEC2_AUDIO_IPAUTH, ip_auth, DSP_MEM_TYPE_PM);
9367 }
9368 }
9369
9370 ////////////////////////////////////////////////////////////////////////////////
9371 /// @brief \b Function \b Name: HAL_AUDIO_Set_DecimationMode()
9372 /// @brief \b Function \b Description: HAL_AUDIO_Set_Decimation register
9373 /// @param <IN> \b AUDIO_OUTPUT_TYPE Output_Type: Audio Output type
9374 /// @param <IN> \b MS_BOOL Enable : Audio ID: ADEC ID
9375 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type,Audio_id ID)9376 void HAL_AUDIO_Set_DecimationMode(AUDIO_OUTPUT_TYPE Output_Type, Audio_id ID)
9377 {
9378
9379 switch(Output_Type)
9380 {
9381 case AUDIO_HDMI_OUTPUT: //high rate nonPCM application need decimation
9382 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))
9383 {
9384 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x04);
9385 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x10);
9386 }
9387 else
9388 {
9389 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x04, 0x00);
9390 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x10, 0x00);
9391 }
9392 break;
9393
9394 case AUDIO_HDMI_ARC_OUTPUT:
9395 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_HDMITx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
9396 {
9397 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x02);
9398 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x08);
9399 }
9400 else
9401 {
9402 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x02, 0x00);
9403 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x08, 0x00);
9404 }
9405 break;
9406
9407 case AUDIO_SPDIF_OUTPUT:
9408 if( (HAL_DEC_R2_Get_SHM_INFO(R2_SHM_INFO_SPDIFTx_SMP_RATE, ID) > 48000) && (HAL_AUDIO_ReadByte(REG_M2D_MAILBOX_SPDIF_CTRL)&0x02))
9409 {
9410 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x01);
9411 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x04);
9412 }
9413 else
9414 {
9415 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DECIMATION_CFG, 0x01, 0x00);
9416 HAL_AUDIO_WriteMaskByte(REG_M2D_MAILBOX_SPDIF_CTRL+1, 0x04, 0x00);
9417 }
9418 break;
9419
9420 default:
9421 break;
9422 }
9423 }
9424
9425 ////////////////////////////////////////////////////////////////////////////////
9426 /// @brief \b Function \b Name: HAL_AUDIO_CheckPlayDone()
9427 /// @brief \b Function \b Description: Check file play done. If file play done, will return TRUE
9428 /// @param <IN> \b NONE :
9429 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
9430 /// @param <GLOBAL> \b NONE :
9431 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckPlayDone(void)9432 MS_BOOL HAL_AUDIO_CheckPlayDone(void)
9433 {
9434 if ( ((HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_okFrmCnt) !=0) ||
9435 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_errFrmCnt) !=0)) &&
9436 (HAL_MAD_GetCommInfo(Audio_Comm_infoType_ADEC1_pcmBuf_currLevel) < AUD_R2_DMA_BURST_BYTES))
9437 {
9438 CheckPlayDoneCnt = CheckPlayDoneCnt + 1;
9439
9440 if (CheckPlayDoneCnt == 3)
9441 {
9442 CheckPlayDoneCnt = 0;
9443 return TRUE;
9444 }
9445 return FALSE;
9446 }
9447 else
9448 {
9449 CheckPlayDoneCnt = 0;
9450 return FALSE;
9451 }
9452 }
9453
9454 ////////////////////////////////////////////////////////////////////////////////
9455 /// @brief \b Function \b Name: HAL_AUDIO_CheckVersionInfo()
9456 /// @brief \b Function \b Description: Check Version info
9457 /// @param <IN> \b NONE :
9458 /// @param <OUT> \b MS_BOOL : TRUE or FALSE
9459 /// @param <GLOBAL> \b NONE :
9460 ////////////////////////////////////////////////////////////////////////////////
HAL_AUDIO_CheckVersionInfo(void)9461 MS_BOOL HAL_AUDIO_CheckVersionInfo(void)
9462 {
9463 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\r\n \033[1;32m==========Audio R2 & DSP Version Check==================\033[0m");
9464 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\r\n \033[1;32m DEC-R2:0x%06X \033[0m \r\n", DEC_R2_VERSION);
9465 #if ASND_R2_SUPPORT
9466 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\r\n \033[1;32m SND-R2:%06X \033[0m \r\n", SND_R2_VERSION);
9467 #endif
9468 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\r\n \033[1;32m DSP System:0x%06X \033[0m \r\n", system_version_num);
9469
9470 if(HAL_AUDIO_AbsReadReg(MBOX_D2M_03AA) != DEC_R2_VERSION) // Compare DEC R2 Version with Mail Box
9471 {
9472 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_INFO, "\r\n \033[1;32m Audio DEC-R2 Version Mismatch!!!!!!! \033[0m \r\n");
9473 }
9474 return TRUE;
9475 }
9476
HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue,MS_U32 * pData)9477 MS_S32 HAL_AUDIO_PCM_Dump_Setting(MS_U32 u32alue, MS_U32 *pData)
9478 {
9479 return 0;
9480 }
9481
HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue,MS_U32 * pData,MS_U32 u32Count)9482 MS_S32 HAL_AUDIO_PCM_Check_U32_Param_Valid(MS_U32 u32alue, MS_U32 *pData, MS_U32 u32Count)
9483 {
9484 MS_U32 u32Loop = 0;
9485 MS_S32 s32Ret = -A_EINVAL;
9486
9487 if (u32Count == 0)
9488 {
9489 return -A_EINVAL;
9490 }
9491
9492 if (pData != NULL)
9493 {
9494 for (u32Loop = 0; u32Loop < u32Count ; u32Loop++)
9495 {
9496 if (pData[u32Loop] == 0)
9497 {
9498 break;
9499 }
9500
9501 if (u32alue == pData[u32Loop])
9502 {
9503 s32Ret = 0;
9504 break;
9505 }
9506 }
9507 }
9508 else
9509 {
9510 s32Ret = -A_EFAULT;
9511 }
9512
9513 return s32Ret;
9514 }
9515
9516 #if AUDIO_HW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)9517 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting(void)
9518 {
9519 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9520 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9521 MS_U16 u16Divisor = 0;
9522 MS_U16 u16Synthrate = 0;
9523 MS_U32 u32TargetBufferSize = 0;
9524 MS_U32 u32TargetChannel = 0;
9525 MS_U32 u32TargetBitWidth = 0;
9526 MS_U32 u32TargetAlignmentSize = 0;
9527 MS_S32 s32Ret = 0;
9528
9529 /*
9530 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
9531 */
9532 switch(pPcmInfo->u32SampleRate) {
9533 case 8000:
9534 {
9535 u16Divisor = 2;
9536 u16Synthrate = 0x6978;
9537 break;
9538 }
9539
9540 case 11025:
9541 {
9542 u16Divisor = 2;
9543 u16Synthrate = 0x4C87;
9544 break;
9545 }
9546
9547 case 12000:
9548 {
9549 u16Divisor = 2;
9550 u16Synthrate = 0x4650;
9551 break;
9552 }
9553
9554 case 16000:
9555 {
9556 u16Divisor = 1;
9557 u16Synthrate = 0x6978;
9558 break;
9559 }
9560
9561 case 22050:
9562 {
9563 u16Divisor = 1;
9564 u16Synthrate = 0x4C87;
9565 break;
9566 }
9567
9568 case 24000:
9569 {
9570 u16Divisor = 1;
9571 u16Synthrate = 0x4650;
9572 break;
9573 }
9574
9575 case 32000:
9576 {
9577 u16Divisor = 0;
9578 u16Synthrate = 0x6978;
9579 break;
9580 }
9581
9582 case 44100:
9583 {
9584 u16Divisor = 0;
9585 u16Synthrate = 0x4C87;
9586 break;
9587 }
9588
9589 case 48000:
9590 {
9591 u16Divisor = 0;
9592 u16Synthrate = 0x4650;
9593 break;
9594 }
9595
9596 default:
9597 {
9598 u16Divisor = 0;
9599 u16Synthrate = 0x4650;
9600 pPcmInfo->u32SampleRate = 48000;
9601 break;
9602 }
9603 }
9604
9605 /* enable DMA synthesizer */
9606 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG0, 0x20, 0x20);
9607
9608 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
9609 HAL_AUDIO_WriteMaskReg(REG_AUDIO_CLK_CFG6, 0x6000, (u16Divisor << 13));
9610 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_SYNTH_NF, 0xFFFF, u16Synthrate);
9611
9612 /* calculate buffer size */
9613 u32TargetChannel = 2;
9614 u32TargetBitWidth = 16;
9615 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9616 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9617 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9618 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
9619 {
9620 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate);
9621 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
9622 pPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
9623 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
9624 }
9625
9626 /* set buffer size */
9627 u32TargetBufferSize = u32TargetBufferSize * 2; /* for HW DMA Reader specification */
9628 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_3, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
9629
9630 /* set overrun & underrun threshold */
9631 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_4, 0xFFFF, u32TargetBufferSize - 12);
9632 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_5, 0xFFFF, 0x0012);
9633
9634 pPCM->u8SettingChangeFlag = FALSE;
9635
9636 return s32Ret;
9637 }
9638
HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)9639 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Restart(void)
9640 {
9641 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9642 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9643 MS_S32 s32Ret = 0;
9644
9645 if (pPcmInfo->u8ConnectFlag == FALSE)
9646 {
9647 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9648 return -A_EPERM;
9649 }
9650
9651 /* clear PCM buffer */
9652 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR1_BUF_SIZE);
9653
9654 /* flush MIU */
9655 MsOS_FlushMemory();
9656
9657 /* clear engine's write pointer */
9658 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, 0x0000);
9659
9660 /* reset & start engine */
9661 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x6402);
9662 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0xFFFE, 0x2402);
9663
9664 /* reset write pointer */
9665 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9666
9667 /* reset remain size */
9668 pPCM->tPcmBufferInfo.u32RemainSize = 0;
9669
9670 return s32Ret;
9671 }
9672
HAL_AUDIO_PCM_HwDma_Reader1_Open(void * pData)9673 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Open(void *pData)
9674 {
9675 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9676 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9677 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
9678 MS_U32 u32TargetBufferAddrPa = 0;
9679 MS_U32 u32TargetBufferSize = 0;
9680 MS_U32 u32TargetChannel = 0;
9681 MS_U32 u32TargetBitWidth = 0;
9682 MS_U32 u32TargetAlignmentSize = 0;
9683 MS_S32 s32Ret = 0;
9684 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
9685
9686 if (pData == NULL)
9687 {
9688 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9689 return -A_EFAULT;
9690 }
9691
9692 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
9693
9694 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
9695 {
9696 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
9697 return -A_EINVAL;
9698 }
9699
9700 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
9701 {
9702 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
9703 return -A_EINVAL;
9704 }
9705
9706 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9707 {
9708 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9709 return -A_EINVAL;
9710 }
9711
9712 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9713 {
9714 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9715 return -A_EINVAL;
9716 }
9717
9718 if (pUserPcmInfo->u8CaptureFlag == TRUE)
9719 {
9720 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
9721 return -A_EINVAL;
9722 }
9723
9724 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)
9725 {
9726 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
9727 return -A_EINVAL;
9728 }
9729
9730 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)
9731 {
9732 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
9733 return -A_EINVAL;
9734 }
9735
9736 /* calculate buffer size */
9737 u32TargetChannel = 2;
9738 u32TargetBitWidth = 16;
9739 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
9740 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
9741 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
9742 if (u32TargetBufferSize > (HW_DMA_RDR1_BUF_SIZE / 2))
9743 {
9744 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate);
9745 u32TargetBufferSize = HW_DMA_RDR1_BUF_SIZE / 2;
9746 pUserPcmInfo->u32BufferDuration = (u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8));
9747 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
9748 }
9749
9750 /* fill in settings */
9751 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9752 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
9753 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
9754 pPcmInfo->u8ConnectFlag = TRUE;
9755 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
9756 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
9757 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
9758 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
9759 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
9760 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
9761 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
9762 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
9763 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
9764 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
9765 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
9766 HAL_AUDIO_PCM_HwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
9767
9768 /* init PCM buffer address */
9769 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR1_BUF_ADDR;
9770 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
9771 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
9772 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
9773
9774 /* set PCM buffer address */
9775 HAL_AUDIO_WriteMaskByte(REG_AUDIO_DMA_RD_CTRL_7, 0xFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFF)); /* RD_BASE_ADDR[7:0] */
9776 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_2, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 8) & 0xFFFF)); /* RD_BASE_ADDR[23:8] */
9777 HAL_AUDIO_WriteMaskByte((REG_AUDIO_DMA_RD_CTRL_7 + 1), 0x0F, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 24) & 0x0F)); /* RD_BASE_ADDR[27:24] */
9778
9779 /* set SEL_CLK_DMA_READER */
9780 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CLK_CFG6, 0x07, 0x04);
9781
9782 /* apply setting */
9783 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
9784
9785 /* restart */
9786 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9787
9788 /* TODO : force channel8 to HW DMA Reader1, it's a hardcode */
9789 HAL_AUDIO_WriteMaskByte(0x2CB0, 0x07, 0x04);
9790 HAL_AUDIO_WriteMaskByte(0x2C6B, 0xFF, 0x8F);
9791
9792 return s32Ret;
9793 }
9794
HAL_AUDIO_PCM_HwDma_Reader1_Close(void)9795 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Close(void)
9796 {
9797 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9798 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9799 MS_S32 s32Ret = 0;
9800 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
9801
9802 if (pPcmInfo->u8ConnectFlag != FALSE)
9803 {
9804 HAL_AUDIO_PCM_HwDma_Reader1_Flush();
9805 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
9806 }
9807
9808 return s32Ret;
9809 }
9810
HAL_AUDIO_PCM_HwDma_Reader1_Start(void)9811 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Start(void)
9812 {
9813 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9814 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9815 MS_S32 s32Ret = 0;
9816 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
9817
9818 if (pPcmInfo->u8StartFlag == FALSE)
9819 {
9820 if (pPCM->u8SettingChangeFlag == TRUE)
9821 {
9822 HAL_AUDIO_PCM_HwDma_Reader1_Apply_Setting();
9823 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
9824 }
9825
9826 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0001);
9827 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0100);
9828
9829 pPcmInfo->u8StartFlag = TRUE;
9830 }
9831
9832 return s32Ret;
9833 }
9834
HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)9835 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Stop(void)
9836 {
9837 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9838 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9839 MS_S32 s32Ret = 0;
9840 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
9841
9842 if (pPcmInfo->u8StartFlag != FALSE)
9843 {
9844 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0001, 0x0000);
9845 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0100, 0x0000);
9846
9847 pPcmInfo->u8StartFlag = FALSE;
9848 }
9849
9850 return s32Ret;
9851 }
9852
HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)9853 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
9854 {
9855 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
9856 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
9857 MS_S32 s32Ret = 0;
9858 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
9859
9860 if (pData == NULL)
9861 {
9862 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
9863 return -A_EFAULT;
9864 }
9865
9866 if (pPcmInfo->u8ConnectFlag == FALSE)
9867 {
9868 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
9869 return -A_EPERM;
9870 }
9871
9872 switch(u32Cmd)
9873 {
9874 case AUDIO_PCM_CMD_NONBLOCKING:
9875 {
9876 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
9877
9878 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
9879 {
9880 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
9881 s32Ret = -A_EINVAL;
9882 break;
9883 }
9884
9885 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
9886
9887 break;
9888 }
9889
9890 case AUDIO_PCM_CMD_MULTICH:
9891 {
9892 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
9893
9894 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
9895 {
9896 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
9897 s32Ret = -A_EINVAL;
9898 break;
9899 }
9900
9901 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
9902 {
9903 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
9904 s32Ret = -A_EINVAL;
9905 break;
9906 }
9907
9908 pPcmInfo->u8MultiChFlag = FALSE;
9909
9910 break;
9911 }
9912
9913 case AUDIO_PCM_CMD_MIXING:
9914 {
9915 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
9916
9917 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
9918 {
9919 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
9920 s32Ret = -A_EINVAL;
9921 break;
9922 }
9923
9924 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
9925 {
9926 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
9927 s32Ret = -A_EINVAL;
9928 break;
9929 }
9930
9931 pPcmInfo->u8MixingFlag = FALSE;
9932
9933 break;
9934 }
9935
9936 case AUDIO_PCM_CMD_MIXINGGROUP:
9937 {
9938 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
9939
9940 pPcmInfo->u32MixingGroup = u32MixingGroup;
9941
9942 break;
9943 }
9944
9945 case AUDIO_PCM_CMD_BUFFERDURATION:
9946 {
9947 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
9948
9949 if (u32BufferDuration == 0)
9950 {
9951 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
9952 s32Ret = -A_EINVAL;
9953 break;
9954 }
9955
9956 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
9957 {
9958 pPcmInfo->u32BufferDuration = u32BufferDuration;
9959 pPCM->u8SettingChangeFlag = TRUE;
9960 }
9961
9962 break;
9963 }
9964
9965 case AUDIO_PCM_CMD_CHANNEL:
9966 {
9967 MS_U32 u32Channel = *((MS_U32 *)pData);
9968
9969 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
9970 {
9971 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
9972 return -A_EINVAL;
9973 }
9974
9975 pPcmInfo->u32Channel = u32Channel;
9976
9977 break;
9978 }
9979
9980 case AUDIO_PCM_CMD_SAMPLERATE:
9981 {
9982 MS_U32 u32SampleRate = *((MS_U32 *)pData);
9983
9984 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
9985 {
9986 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
9987 return -A_EINVAL;
9988 }
9989
9990 if (pPcmInfo->u32SampleRate != u32SampleRate)
9991 {
9992 pPcmInfo->u32SampleRate = u32SampleRate;
9993 pPCM->u8SettingChangeFlag = TRUE;
9994 }
9995
9996 break;
9997 }
9998
9999 case AUDIO_PCM_CMD_BITWIDTH:
10000 {
10001 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10002
10003 pPcmInfo->u32BitWidth = u32BitWidth;
10004
10005 break;
10006 }
10007
10008 case AUDIO_PCM_CMD_BIGENDIAN:
10009 {
10010 MS_U32 u32BigEndian = *((MS_U32 *)pData);
10011
10012 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
10013 {
10014 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
10015 return -A_EINVAL;
10016 }
10017
10018 pPcmInfo->u32BigEndian = u32BigEndian;
10019
10020 break;
10021 }
10022
10023 case AUDIO_PCM_CMD_TIMESTAMP:
10024 {
10025 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10026
10027 pPcmInfo->u32Timestamp = u32Timestamp;
10028
10029 break;
10030 }
10031
10032 case AUDIO_PCM_CMD_WEIGHTING:
10033 {
10034 MS_U32 u32Weighting = *((MS_U32 *)pData);
10035
10036 if (u32Weighting > 100)
10037 {
10038 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
10039 return -A_EINVAL;
10040 }
10041
10042 pPcmInfo->u32Weighting = u32Weighting;
10043
10044 break;
10045 }
10046
10047 case AUDIO_PCM_CMD_VOLUME:
10048 {
10049 MS_U32 u32Volume = *((MS_U32 *)pData);
10050
10051 if (u32Volume > 100)
10052 {
10053 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
10054 return -A_EINVAL;
10055 }
10056
10057 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
10058
10059 break;
10060 }
10061
10062 case AUDIO_PCM_CMD_MUTE:
10063 {
10064 MS_U32 u32Mute = *((MS_U32*)pData);
10065
10066 if (u32Mute == TRUE)
10067 {
10068 pPcmInfo->u32Volume |= 0x80000000;
10069 }
10070 else if (u32Mute == FALSE)
10071 {
10072 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10073 }
10074 else
10075 {
10076 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
10077 s32Ret = -A_EINVAL;
10078 }
10079 break;
10080 }
10081
10082 default:
10083 {
10084 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10085 break;
10086 }
10087 }
10088
10089 return s32Ret;
10090 }
10091
HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)10092 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
10093 {
10094 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
10095 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10096 MS_S32 s32Ret = 0;
10097 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10098
10099 if (pData == NULL)
10100 {
10101 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10102 return -A_EFAULT;
10103 }
10104
10105 if (pPcmInfo->u8ConnectFlag == FALSE)
10106 {
10107 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10108 return -A_EPERM;
10109 }
10110
10111 switch(u32Cmd)
10112 {
10113 case AUDIO_PCM_CMD_ALL:
10114 {
10115 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10116 MS_U32 u32MinSize = 0;
10117
10118 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10119 {
10120 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10121 s32Ret = -A_EINVAL;
10122 break;
10123 }
10124 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
10125 {
10126 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10127 }
10128
10129 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
10130 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
10131 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
10132
10133 break;
10134 }
10135
10136 case AUDIO_PCM_CMD_NONBLOCKING:
10137 {
10138 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
10139 break;
10140 }
10141
10142 case AUDIO_PCM_CMD_MULTICH:
10143 {
10144 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
10145 break;
10146 }
10147
10148 case AUDIO_PCM_CMD_MIXING:
10149 {
10150 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
10151 break;
10152 }
10153
10154 case AUDIO_PCM_CMD_MIXINGGROUP:
10155 {
10156 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
10157 break;
10158 }
10159
10160 case AUDIO_PCM_CMD_BUFFER:
10161 {
10162 /*
10163 * TODO, need better coding
10164 *
10165 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
10166 */
10167 break;
10168 }
10169
10170 case AUDIO_PCM_CMD_BUFFERDURATION:
10171 {
10172 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
10173 break;
10174 }
10175
10176 case AUDIO_PCM_CMD_READPTR:
10177 {
10178 /*
10179 * TODO, need better coding
10180 *
10181 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
10182 */
10183 break;
10184 }
10185
10186 case AUDIO_PCM_CMD_WRITEPTR:
10187 {
10188 /*
10189 * TODO, need better coding
10190 *
10191 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
10192 */
10193 break;
10194 }
10195
10196 case AUDIO_PCM_CMD_CHANNEL:
10197 {
10198 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
10199 break;
10200 }
10201
10202 case AUDIO_PCM_CMD_SAMPLERATE:
10203 {
10204 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
10205 break;
10206 }
10207
10208 case AUDIO_PCM_CMD_BITWIDTH:
10209 {
10210 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
10211 break;
10212 }
10213
10214 case AUDIO_PCM_CMD_BIGENDIAN:
10215 {
10216 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
10217 break;
10218 }
10219
10220 case AUDIO_PCM_CMD_TIMESTAMP:
10221 {
10222 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
10223 break;
10224 }
10225
10226 case AUDIO_PCM_CMD_WEIGHTING:
10227 {
10228 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
10229 break;
10230 }
10231
10232 case AUDIO_PCM_CMD_VOLUME:
10233 {
10234 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
10235 break;
10236 }
10237
10238 case AUDIO_PCM_CMD_BUFFERLEVEL:
10239 {
10240 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0010);
10241 pPcmInfo->u32BufferLevel = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_6) * BYTES_IN_MIU_LINE) / 2;
10242 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_0, 0x0010, 0x0000);
10243 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
10244 break;
10245 }
10246
10247 case AUDIO_PCM_CMD_MUTE:
10248 {
10249 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
10250 break;
10251 }
10252
10253 case AUDIO_PCM_CMD_BUFFERSIZE:
10254 {
10255 *((MS_U32 *)pData) = (HAL_AUDIO_ReadReg(REG_AUDIO_DMA_RD_CTRL_3) * BYTES_IN_MIU_LINE) / 2; /* return valid size */
10256 break;
10257 }
10258
10259 default:
10260 {
10261 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
10262 break;
10263 }
10264 }
10265
10266 return s32Ret;
10267 }
10268
HAL_AUDIO_PCM_HwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)10269 MS_U32 HAL_AUDIO_PCM_HwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
10270 {
10271 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
10272 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10273 MS_S8 *pBufTmp = NULL;
10274 MS_U32 u32BufferSize = 0;
10275 MS_U32 u32PcmLevel = 0;
10276 MS_U32 u32RequestSize = 0;
10277 MS_U32 u32RequestSampleCount = 0;
10278 MS_U32 u32Loop = 0;
10279 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
10280
10281 if (pBuf == NULL)
10282 {
10283 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
10284 return 0;
10285 }
10286
10287 if (u32Size == 0)
10288 {
10289 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
10290 return 0;
10291 }
10292
10293 if (pPcmInfo->u8ConnectFlag == FALSE)
10294 {
10295 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10296 return 0;
10297 }
10298
10299 if (pPcmInfo->u8StartFlag == FALSE)
10300 {
10301 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
10302 return 0;
10303 }
10304
10305 pBufTmp = (MS_S8 *)pBuf;
10306
10307 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
10308 u32PcmLevel = u32PcmLevel * 2;
10309 if ((u32PcmLevel / BYTES_IN_MIU_LINE) <= 6)
10310 {
10311 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
10312
10313 u32PcmLevel = 0;
10314 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
10315 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
10316 HAL_AUDIO_PCM_HwDma_Reader1_Start();
10317 }
10318
10319 u32RequestSize = u32Size * 2;
10320 u32RequestSampleCount = u32Size / 2;
10321
10322 HAL_AUDIO_PCM_HwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
10323 u32BufferSize = u32BufferSize * 2;
10324
10325 /* copy data to PCM buffer */
10326 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
10327 {
10328 for (u32Loop = 0; u32Loop < u32RequestSampleCount; u32Loop++)
10329 {
10330 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
10331 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L low, R low, L low, R low, ... */
10332 *pPCM->tPcmBufferInfo.pWritePtr++ = *pBufTmp++; /* L high, R high, L high, R high, ... */
10333 *pPCM->tPcmBufferInfo.pWritePtr++ = 0;
10334
10335 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10336 {
10337 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
10338 {
10339 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
10340 }
10341 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10342 }
10343 }
10344
10345 /* flush MIU */
10346 MsOS_FlushMemory();
10347
10348 /* update copied size to engine */
10349 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
10350 HAL_AUDIO_WriteMaskReg(REG_AUDIO_DMA_RD_CTRL_1, 0xFFFF, (u32RequestSize/BYTES_IN_MIU_LINE));
10351 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
10352 #ifdef MSOS_TYPE_LINUX_KERNEL
10353 udelay(50);
10354 #else
10355 AUDIO_DELAY1US(50);
10356 #endif
10357
10358 return u32Size;
10359 }
10360
10361 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
10362
10363 return 0;
10364 }
10365
HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)10366 MS_S32 HAL_AUDIO_PCM_HwDma_Reader1_Flush(void)
10367 {
10368 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader1;
10369 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10370 MS_S32 s32Ret = 0;
10371 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
10372
10373 if (pPcmInfo->u8StartFlag == FALSE)
10374 {
10375 HAL_AUDIO_PCM_HwDma_Reader1_Restart();
10376 HAL_AUDIO_PCM_HwDma_Reader1_Stop();
10377 }
10378
10379 return s32Ret;
10380 }
10381 #endif
10382
10383 #if AUDIO_HW_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)10384 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting(void)
10385 {
10386 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10387 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10388 MS_U16 u16Divisor = 0;
10389 MS_U16 u16Synthrate = 0;
10390 MS_U32 u32TargetBufferSize = 0;
10391 MS_U32 u32TargetChannel = 0;
10392 MS_U32 u32TargetBitWidth = 0;
10393 MS_U32 u32TargetAlignmentSize = 0;
10394 MS_S32 s32Ret = 0;
10395
10396 /*
10397 * synthesizer Rate = 216MHz / divisor(1, 2, 4 or 8) * 1024 / 256 / sampling rate(32Khz, 44.1KHz or 48KHz)
10398 */
10399 switch(pPcmInfo->u32SampleRate) {
10400 case 8000:
10401 {
10402 u16Divisor = 2;
10403 u16Synthrate = 0x6978;
10404 break;
10405 }
10406
10407 case 11025:
10408 {
10409 u16Divisor = 2;
10410 u16Synthrate = 0x4C87;
10411 break;
10412 }
10413
10414 case 12000:
10415 {
10416 u16Divisor = 2;
10417 u16Synthrate = 0x4650;
10418 break;
10419 }
10420
10421 case 16000:
10422 {
10423 u16Divisor = 1;
10424 u16Synthrate = 0x6978;
10425 break;
10426 }
10427
10428 case 22050:
10429 {
10430 u16Divisor = 1;
10431 u16Synthrate = 0x4C87;
10432 break;
10433 }
10434
10435 case 24000:
10436 {
10437 u16Divisor = 1;
10438 u16Synthrate = 0x4650;
10439 break;
10440 }
10441
10442 case 32000:
10443 {
10444 u16Divisor = 0;
10445 u16Synthrate = 0x6978;
10446 break;
10447 }
10448
10449 case 44100:
10450 {
10451 u16Divisor = 0;
10452 u16Synthrate = 0x4C87;
10453 break;
10454 }
10455
10456 case 48000:
10457 {
10458 u16Divisor = 0;
10459 u16Synthrate = 0x4650;
10460 break;
10461 }
10462
10463 default:
10464 {
10465 u16Divisor = 0;
10466 u16Synthrate = 0x4650;
10467 pPcmInfo->u32SampleRate = 48000;
10468 break;
10469 }
10470 }
10471
10472 /* Configure REG_SEL_CLK_214MHZ_DMA_RD_FIX_SYNTH & synthesizer N.F. */
10473 HAL_AUDIO_AbsWriteReg(NewDMAreader_ctrl, 0x0000);
10474 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0030, (u16Divisor << 4));
10475 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Syth, 0xFFFF, u16Synthrate);
10476
10477 /* enable DMA synthesizer */
10478 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_Enable_ctrl, 0x0145, 0x0145);
10479
10480 /* calculate buffer size */
10481 u32TargetChannel = 2;
10482 u32TargetBitWidth = 16;
10483 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10484 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10485 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10486 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
10487 {
10488 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pPcmInfo->u32BufferDuration, (unsigned int)pPcmInfo->u32SampleRate);
10489 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
10490 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10491 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
10492 }
10493
10494 /* set buffer size */
10495 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
10496
10497 /* set overrun & underrun threshold */
10498 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_DRAM_underrun_threshold, 0xFFFF, 0x0012);
10499
10500 pPCM->u8SettingChangeFlag = FALSE;
10501
10502 return s32Ret;
10503 }
10504
HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)10505 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Restart(void)
10506 {
10507 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10508 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10509 MS_S32 s32Ret = 0;
10510
10511 if (pPcmInfo->u8ConnectFlag == FALSE)
10512 {
10513 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10514 return -A_EPERM;
10515 }
10516
10517 /* clear PCM buffer */
10518 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_RDR2_BUF_SIZE);
10519
10520 /* flush MIU */
10521 MsOS_FlushMemory();
10522
10523 /* clear engine's write pointer */
10524 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, 0x0000);
10525
10526 /* reset & start engine */
10527 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
10528 #ifdef MSOS_TYPE_LINUX_KERNEL
10529 udelay(50);
10530 #else
10531 AUDIO_DELAY1US(50);
10532 #endif
10533 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
10534
10535 /* reset write pointer */
10536 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10537
10538 /* reset remain size */
10539 pPCM->tPcmBufferInfo.u32RemainSize = 0;
10540
10541 return s32Ret;
10542 }
10543
HAL_AUDIO_PCM_HwDma_Reader2_Open(void * pData)10544 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Open(void *pData)
10545 {
10546 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10547 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10548 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
10549 MS_U32 u32TargetBufferAddrPa = 0;
10550 MS_U32 u32TargetBufferSize = 0;
10551 MS_U32 u32TargetChannel = 0;
10552 MS_U32 u32TargetBitWidth = 0;
10553 MS_U32 u32TargetAlignmentSize = 0;
10554 MS_S32 s32Ret = 0;
10555 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
10556
10557 if (pData == NULL)
10558 {
10559 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10560 return -A_EFAULT;
10561 }
10562
10563 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10564
10565 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10566 {
10567 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10568 return -A_EINVAL;
10569 }
10570
10571 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
10572 {
10573 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
10574 return -A_EINVAL;
10575 }
10576
10577 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10578 {
10579 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10580 return -A_EINVAL;
10581 }
10582
10583 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10584 {
10585 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10586 return -A_EINVAL;
10587 }
10588
10589 if (pUserPcmInfo->u8CaptureFlag == TRUE)
10590 {
10591 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
10592 return -A_EINVAL;
10593 }
10594
10595 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)
10596 {
10597 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
10598 return -A_EINVAL;
10599 }
10600
10601 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)
10602 {
10603 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
10604 return -A_EINVAL;
10605 }
10606
10607 /* calculate buffer size */
10608 u32TargetChannel = 2;
10609 u32TargetBitWidth = 16;
10610 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
10611 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
10612 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
10613 if (u32TargetBufferSize > HW_DMA_RDR2_BUF_SIZE)
10614 {
10615 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pUserPcmInfo->u32BufferDuration, (unsigned int)pUserPcmInfo->u32SampleRate);
10616 u32TargetBufferSize = HW_DMA_RDR2_BUF_SIZE;
10617 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
10618 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32BufferDuration);
10619 }
10620
10621 /* fill in settings */
10622 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10623 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
10624 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
10625 pPcmInfo->u8ConnectFlag = TRUE;
10626 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
10627 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
10628 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
10629 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
10630 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
10631 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
10632 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
10633 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
10634 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
10635 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
10636 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
10637 HAL_AUDIO_PCM_HwDma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
10638
10639 /* init PCM buffer address */
10640 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_RDR2_BUF_ADDR;
10641 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
10642 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
10643 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
10644
10645 /* set PCM buffer address */
10646 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Lo, 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* RD_BASE_ADDR[15:0] */
10647 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_BaseAddress_Hi, 0xFFFF, (((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16) & 0xFFFF)); /* RD_BASE_ADDR[31:15] */
10648
10649 /* apply setting */
10650 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
10651
10652 /* restart */
10653 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10654
10655 /* TODO : force channel6 to HW DMA Reader2, it's a hardcode */
10656 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x90);
10657
10658 return s32Ret;
10659 }
10660
HAL_AUDIO_PCM_HwDma_Reader2_Close(void)10661 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Close(void)
10662 {
10663 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10664 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10665 MS_S32 s32Ret = 0;
10666 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
10667
10668 if (pPcmInfo->u8ConnectFlag != FALSE)
10669 {
10670 HAL_AUDIO_PCM_HwDma_Reader2_Flush();
10671 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
10672 }
10673
10674 return s32Ret;
10675 }
10676
HAL_AUDIO_PCM_HwDma_Reader2_Start(void)10677 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Start(void)
10678 {
10679 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10680 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10681 MS_S32 s32Ret = 0;
10682 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
10683
10684 if (pPcmInfo->u8StartFlag == FALSE)
10685 {
10686 if (pPCM->u8SettingChangeFlag == TRUE)
10687 {
10688 HAL_AUDIO_PCM_HwDma_Reader2_Apply_Setting();
10689 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
10690 }
10691
10692 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0001);
10693 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0002);
10694
10695 pPcmInfo->u8StartFlag = TRUE;
10696 }
10697
10698 return s32Ret;
10699 }
10700
HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)10701 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Stop(void)
10702 {
10703 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10704 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10705 MS_S32 s32Ret = 0;
10706 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
10707
10708 if (pPcmInfo->u8StartFlag != FALSE)
10709 {
10710 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0001, 0x0000);
10711 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0002, 0x0000);
10712
10713 pPcmInfo->u8StartFlag = FALSE;
10714 }
10715
10716 return s32Ret;
10717 }
10718
HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd,const void * pData)10719 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
10720 {
10721 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10722 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10723 MS_S32 s32Ret = 0;
10724 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10725
10726 if (pData == NULL)
10727 {
10728 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10729 return -A_EFAULT;
10730 }
10731
10732 if (pPcmInfo->u8ConnectFlag == FALSE)
10733 {
10734 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10735 return -A_EPERM;
10736 }
10737
10738 switch(u32Cmd)
10739 {
10740 case AUDIO_PCM_CMD_NONBLOCKING:
10741 {
10742 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
10743
10744 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
10745 {
10746 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
10747 s32Ret = -A_EINVAL;
10748 break;
10749 }
10750
10751 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
10752
10753 break;
10754 }
10755
10756 case AUDIO_PCM_CMD_MULTICH:
10757 {
10758 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
10759
10760 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
10761 {
10762 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
10763 s32Ret = -A_EINVAL;
10764 break;
10765 }
10766
10767 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
10768 {
10769 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
10770 s32Ret = -A_EINVAL;
10771 break;
10772 }
10773
10774 pPcmInfo->u8MultiChFlag = FALSE;
10775
10776 break;
10777 }
10778
10779 case AUDIO_PCM_CMD_MIXING:
10780 {
10781 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
10782
10783 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
10784 {
10785 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
10786 s32Ret = -A_EINVAL;
10787 break;
10788 }
10789
10790 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
10791 {
10792 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
10793 s32Ret = -A_EINVAL;
10794 break;
10795 }
10796
10797 pPcmInfo->u8MixingFlag = FALSE;
10798
10799 break;
10800 }
10801
10802 case AUDIO_PCM_CMD_MIXINGGROUP:
10803 {
10804 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
10805
10806 pPcmInfo->u32MixingGroup = u32MixingGroup;
10807
10808 break;
10809 }
10810
10811 case AUDIO_PCM_CMD_BUFFERDURATION:
10812 {
10813 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
10814
10815 if (u32BufferDuration == 0)
10816 {
10817 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
10818 s32Ret = -A_EINVAL;
10819 break;
10820 }
10821
10822 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
10823 {
10824 pPcmInfo->u32BufferDuration = u32BufferDuration;
10825 pPCM->u8SettingChangeFlag = TRUE;
10826 }
10827
10828 break;
10829 }
10830
10831 case AUDIO_PCM_CMD_CHANNEL:
10832 {
10833 MS_U32 u32Channel = *((MS_U32 *)pData);
10834
10835 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
10836 {
10837 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, (unsigned int)u32Channel);
10838 return -A_EINVAL;
10839 }
10840
10841 pPcmInfo->u32Channel = u32Channel;
10842
10843 break;
10844 }
10845
10846 case AUDIO_PCM_CMD_SAMPLERATE:
10847 {
10848 MS_U32 u32SampleRate = *((MS_U32 *)pData);
10849
10850 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
10851 {
10852 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, (unsigned int)u32SampleRate);
10853 return -A_EINVAL;
10854 }
10855
10856 if (pPcmInfo->u32SampleRate != u32SampleRate)
10857 {
10858 pPcmInfo->u32SampleRate = u32SampleRate;
10859 pPCM->u8SettingChangeFlag = TRUE;
10860 }
10861
10862 break;
10863 }
10864
10865 case AUDIO_PCM_CMD_BITWIDTH:
10866 {
10867 MS_U32 u32BitWidth = *((MS_U32 *)pData);
10868
10869 pPcmInfo->u32BitWidth = u32BitWidth;
10870
10871 break;
10872 }
10873
10874 case AUDIO_PCM_CMD_BIGENDIAN:
10875 {
10876 MS_U32 u32BigEndian = *((MS_U32 *)pData);
10877
10878 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
10879 {
10880 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
10881 return -A_EINVAL;
10882 }
10883
10884 pPcmInfo->u32BigEndian = u32BigEndian;
10885
10886 break;
10887 }
10888
10889 case AUDIO_PCM_CMD_TIMESTAMP:
10890 {
10891 MS_U32 u32Timestamp = *((MS_U32 *)pData);
10892
10893 pPcmInfo->u32Timestamp = u32Timestamp;
10894
10895 break;
10896 }
10897
10898 case AUDIO_PCM_CMD_WEIGHTING:
10899 {
10900 MS_U32 u32Weighting = *((MS_U32 *)pData);
10901
10902 if (u32Weighting > 100)
10903 {
10904 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
10905 return -A_EINVAL;
10906 }
10907
10908 pPcmInfo->u32Weighting = u32Weighting;
10909
10910 break;
10911 }
10912
10913 case AUDIO_PCM_CMD_VOLUME:
10914 {
10915 MS_U32 u32Volume = *((MS_U32 *)pData);
10916
10917 if (u32Volume > 100)
10918 {
10919 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
10920 return -A_EINVAL;
10921 }
10922
10923 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
10924
10925 break;
10926 }
10927
10928 case AUDIO_PCM_CMD_MUTE:
10929 {
10930 MS_U32 u32Mute = *((MS_U32*)pData);
10931
10932 if (u32Mute == TRUE)
10933 {
10934 pPcmInfo->u32Volume |= 0x80000000;
10935 }
10936 else if (u32Mute == FALSE)
10937 {
10938 pPcmInfo->u32Volume &= 0x7FFFFFFF;
10939 }
10940 else
10941 {
10942 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
10943 s32Ret = -A_EINVAL;
10944 }
10945 break;
10946 }
10947
10948 default:
10949 {
10950 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
10951 break;
10952 }
10953 }
10954
10955 return s32Ret;
10956 }
10957
HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd,void * pData)10958 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Get(MS_U32 u32Cmd, void *pData)
10959 {
10960 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
10961 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
10962 MS_S32 s32Ret = 0;
10963 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
10964
10965 if (pData == NULL)
10966 {
10967 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
10968 return -A_EFAULT;
10969 }
10970
10971 if (pPcmInfo->u8ConnectFlag == FALSE)
10972 {
10973 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
10974 return -A_EPERM;
10975 }
10976
10977 switch(u32Cmd)
10978 {
10979 case AUDIO_PCM_CMD_ALL:
10980 {
10981 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
10982 MS_U32 u32MinSize = 0;
10983
10984 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
10985 {
10986 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10987 s32Ret = -A_EINVAL;
10988 break;
10989 }
10990 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
10991 {
10992 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
10993 }
10994
10995 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
10996 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
10997 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
10998
10999 break;
11000 }
11001
11002 case AUDIO_PCM_CMD_NONBLOCKING:
11003 {
11004 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11005 break;
11006 }
11007
11008 case AUDIO_PCM_CMD_MULTICH:
11009 {
11010 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11011 break;
11012 }
11013
11014 case AUDIO_PCM_CMD_MIXING:
11015 {
11016 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11017 break;
11018 }
11019
11020 case AUDIO_PCM_CMD_MIXINGGROUP:
11021 {
11022 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11023 break;
11024 }
11025
11026 case AUDIO_PCM_CMD_BUFFER:
11027 {
11028 /*
11029 * TODO, need better coding
11030 *
11031 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
11032 */
11033 break;
11034 }
11035
11036 case AUDIO_PCM_CMD_BUFFERDURATION:
11037 {
11038 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11039 break;
11040 }
11041
11042 case AUDIO_PCM_CMD_READPTR:
11043 {
11044 /*
11045 * TODO, need better coding
11046 *
11047 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
11048 */
11049 break;
11050 }
11051
11052 case AUDIO_PCM_CMD_WRITEPTR:
11053 {
11054 /*
11055 * TODO, need better coding
11056 *
11057 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
11058 */
11059 break;
11060 }
11061
11062 case AUDIO_PCM_CMD_CHANNEL:
11063 {
11064 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11065 break;
11066 }
11067
11068 case AUDIO_PCM_CMD_SAMPLERATE:
11069 {
11070 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11071 break;
11072 }
11073
11074 case AUDIO_PCM_CMD_BITWIDTH:
11075 {
11076 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11077 break;
11078 }
11079
11080 case AUDIO_PCM_CMD_BIGENDIAN:
11081 {
11082 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
11083 break;
11084 }
11085
11086 case AUDIO_PCM_CMD_TIMESTAMP:
11087 {
11088 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11089 break;
11090 }
11091
11092 case AUDIO_PCM_CMD_WEIGHTING:
11093 {
11094 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11095 break;
11096 }
11097
11098 case AUDIO_PCM_CMD_VOLUME:
11099 {
11100 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
11101 break;
11102 }
11103
11104 case AUDIO_PCM_CMD_BUFFERLEVEL:
11105 {
11106 MS_U32 u32BufferLevel1 = 0;
11107 MS_U32 u32BufferLevel2 = 0;
11108 MS_U32 u32Timeout = 20;
11109
11110 while (u32Timeout > 0)
11111 {
11112 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0020);
11113 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
11114 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
11115 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0020, 0x0000);
11116
11117 if (u32BufferLevel1 == u32BufferLevel2)
11118 {
11119 break;
11120 }
11121
11122 u32Timeout--;
11123
11124 #ifdef MSOS_TYPE_LINUX_KERNEL
11125 udelay(1);
11126 #else
11127 AUDIO_DELAY1US(1);
11128 #endif
11129 }
11130
11131 if (u32BufferLevel1 != u32BufferLevel2)
11132 {
11133 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
11134 }
11135
11136 pPcmInfo->u32BufferLevel = u32BufferLevel2;
11137 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
11138
11139 break;
11140 }
11141
11142 case AUDIO_PCM_CMD_MUTE:
11143 {
11144 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
11145 break;
11146 }
11147
11148 case AUDIO_PCM_CMD_BUFFERSIZE:
11149 {
11150 *((MS_U32 *)pData) = HAL_AUDIO_AbsReadReg(NewDMAreader_DRAM_size) * BYTES_IN_MIU_LINE;
11151 break;
11152 }
11153
11154 default:
11155 {
11156 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
11157 break;
11158 }
11159 }
11160
11161 return s32Ret;
11162 }
11163
HAL_AUDIO_PCM_HwDma_Reader2_Write(const void * pBuf,MS_U32 u32Size)11164 MS_U32 HAL_AUDIO_PCM_HwDma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
11165 {
11166 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
11167 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11168 MS_S8 *pBufTmp = NULL;
11169 MS_U32 u32BufferSize = 0;
11170 MS_U32 u32PcmLevel = 0;
11171 MS_U32 u32RequestSize = 0;
11172 MS_U32 u32RequestSizeTmp = 0;
11173 MS_U32 u32SizeToCopy = 0;
11174 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
11175
11176 if (pBuf == NULL)
11177 {
11178 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
11179 return 0;
11180 }
11181
11182 if (u32Size == 0)
11183 {
11184 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
11185 return 0;
11186 }
11187
11188 if (pPcmInfo->u8ConnectFlag == FALSE)
11189 {
11190 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11191 return 0;
11192 }
11193
11194 if (pPcmInfo->u8StartFlag == FALSE)
11195 {
11196 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
11197 return 0;
11198 }
11199
11200 pBufTmp = (MS_S8 *)pBuf;
11201
11202 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
11203 if (u32PcmLevel == 0)
11204 {
11205 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
11206 }
11207
11208 u32RequestSize = u32Size;
11209 u32RequestSizeTmp = u32RequestSize;
11210
11211 HAL_AUDIO_PCM_HwDma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
11212
11213 /* copy data to PCM buffer */
11214 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
11215 {
11216 do {
11217 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
11218 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
11219
11220 #ifdef MSOS_TYPE_LINUX_KERNEL
11221 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11222 #else
11223 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
11224 #endif
11225
11226 pBufTmp += u32SizeToCopy;
11227 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
11228 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
11229 {
11230 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
11231 {
11232 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
11233 }
11234 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11235 }
11236
11237 u32RequestSizeTmp -= u32SizeToCopy;
11238 } while (u32RequestSizeTmp > 0);
11239
11240 /* flush MIU */
11241 MsOS_FlushMemory();
11242
11243 /* update copied size to engine */
11244 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
11245 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0000);
11246 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
11247 HAL_AUDIO_AbsWriteMaskReg(NewDMAreader_ctrl, 0x0010, 0x0010);
11248 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
11249
11250 return u32Size;
11251 }
11252
11253 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
11254
11255 return 0;
11256 }
11257
HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)11258 MS_S32 HAL_AUDIO_PCM_HwDma_Reader2_Flush(void)
11259 {
11260 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Reader2;
11261 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11262 MS_S32 s32Ret = 0;
11263 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
11264
11265 if (pPcmInfo->u8StartFlag == FALSE)
11266 {
11267 HAL_AUDIO_PCM_HwDma_Reader2_Restart();
11268 HAL_AUDIO_PCM_HwDma_Reader2_Stop();
11269 }
11270
11271 return s32Ret;
11272 }
11273 #endif
11274
11275 #if AUDIO_SW_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)11276 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting(void)
11277 {
11278 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11279 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11280 MS_U16 u16Synthrate_H = 0;
11281 MS_U16 u16Synthrate_L = 0;
11282 MS_U32 u32TargetBufferSize = 0;
11283 MS_U32 u32TargetChannel = 0;
11284 MS_U32 u32TargetBitWidth = 0;
11285 MS_U32 u32TargetAlignmentSize = 0;
11286 MS_S32 s32Ret = 0;
11287
11288 switch(pPcmInfo->u32SampleRate) {
11289 case 8000:
11290 {
11291 u16Synthrate_H = 0x6978;
11292 u16Synthrate_L = 0x0000;
11293 break;
11294 }
11295
11296 case 11025:
11297 {
11298 u16Synthrate_H = 0x4C87;
11299 u16Synthrate_L = 0xD634;
11300 break;
11301 }
11302
11303 case 12000:
11304 {
11305 u16Synthrate_H = 0x4650;
11306 u16Synthrate_L = 0x0000;
11307 break;
11308 }
11309
11310 case 16000:
11311 {
11312 u16Synthrate_H = 0x34BC;
11313 u16Synthrate_L = 0x0000;
11314 break;
11315 }
11316
11317 case 22050:
11318 {
11319 u16Synthrate_H = 0x2643;
11320 u16Synthrate_L = 0xEB1A;
11321 break;
11322 }
11323
11324 case 24000:
11325 {
11326 u16Synthrate_H = 0x2328;
11327 u16Synthrate_L = 0x0000;
11328 break;
11329 }
11330
11331 case 32000:
11332 {
11333 u16Synthrate_H = 0x1A5E;
11334 u16Synthrate_L = 0x0000;
11335 break;
11336 }
11337
11338 case 44100:
11339 {
11340 u16Synthrate_H = 0x1321;
11341 u16Synthrate_L = 0xF58D;
11342 break;
11343 }
11344
11345 case 48000:
11346 {
11347 u16Synthrate_H = 0x1194;
11348 u16Synthrate_L = 0x0000;
11349 break;
11350 }
11351
11352 case 96000:
11353 {
11354 u16Synthrate_H = 0x08CA;
11355 u16Synthrate_L = 0x0000;
11356 break;
11357 }
11358
11359 default:
11360 {
11361 u16Synthrate_H = 0x1194;
11362 u16Synthrate_L = 0x0000;
11363 pPcmInfo->u32SampleRate = 48000;
11364 break;
11365 }
11366 }
11367
11368 /* enable reg_dvb5_fix_synth_nf_h */
11369 HAL_AUDIO_WriteMaskReg(0x2C24, 0xA000, 0xA000);
11370
11371 /* configure sample rate */
11372 HAL_AUDIO_WriteMaskReg(0x2C26, 0xFFFF, u16Synthrate_H);
11373 HAL_AUDIO_WriteMaskReg(0x2C28, 0xFFFF, u16Synthrate_L);
11374
11375 /* trigger reg_dvb5_fix_synth_nf_h to apply configuration */
11376 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x1000);
11377 #ifdef MSOS_TYPE_LINUX_KERNEL
11378 udelay(50);
11379 #else
11380 AUDIO_DELAY1US(50);
11381 #endif
11382 HAL_AUDIO_WriteMaskReg(0x2C24, 0x1000, 0x0000);
11383
11384 /* calculate buffer size */
11385 u32TargetChannel = 2;
11386 u32TargetBitWidth = 16;
11387 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11388 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11389 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11390 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
11391 {
11392 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate);
11393 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
11394 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11395 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
11396 }
11397
11398 pPCM->u8SettingChangeFlag = FALSE;
11399
11400 return s32Ret;
11401 }
11402
HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)11403 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Restart(void)
11404 {
11405 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11406 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11407 MS_S32 s32Ret = 0;
11408
11409 if (pPcmInfo->u8ConnectFlag == FALSE)
11410 {
11411 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11412 return -A_EPERM;
11413 }
11414
11415 /* clear PCM buffer */
11416 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, SW_DMA_RDR1_BUF_SIZE);
11417
11418 /* flush MIU */
11419 MsOS_FlushMemory();
11420
11421 /* clear engine's write pointer */
11422 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, 0x0000);
11423
11424 /* reset engine, no start engine here! */
11425 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0001);
11426
11427 /* reset write pointer */
11428 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11429
11430 /* reset remain size */
11431 pPCM->tPcmBufferInfo.u32RemainSize = 0;
11432
11433 return s32Ret;
11434 }
11435
HAL_AUDIO_PCM_SwDma_Reader1_Open(void * pData)11436 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Open(void *pData)
11437 {
11438 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11439 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11440 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
11441 MS_U32 u32TargetBufferAddrPa = 0;
11442 MS_U32 u32TargetBufferSize = 0;
11443 MS_U32 u32TargetChannel = 0;
11444 MS_U32 u32TargetBitWidth = 0;
11445 MS_U32 u32TargetAlignmentSize = 0;
11446 MS_S32 s32Ret = 0;
11447 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
11448
11449 if (pData == NULL)
11450 {
11451 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11452 return -A_EFAULT;
11453 }
11454
11455 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11456
11457 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11458 {
11459 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11460 return -A_EINVAL;
11461 }
11462
11463 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
11464 {
11465 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
11466 return -A_EINVAL;
11467 }
11468
11469 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11470 {
11471 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11472 return -A_EINVAL;
11473 }
11474
11475 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11476 {
11477 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11478 return -A_EINVAL;
11479 }
11480
11481 if (pUserPcmInfo->u8CaptureFlag == TRUE)
11482 {
11483 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
11484 return -A_EINVAL;
11485 }
11486
11487 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)
11488 {
11489 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
11490 return -A_EINVAL;
11491 }
11492
11493 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)
11494 {
11495 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
11496 return -A_EINVAL;
11497 }
11498
11499 /* calculate buffer size */
11500 u32TargetChannel = 2;
11501 u32TargetBitWidth = 16;
11502 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
11503 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
11504 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
11505 if (u32TargetBufferSize > SW_DMA_RDR1_BUF_SIZE)
11506 {
11507 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate);
11508 u32TargetBufferSize = SW_DMA_RDR1_BUF_SIZE;
11509 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
11510 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
11511 }
11512
11513 /* fill in settings */
11514 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11515 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
11516 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
11517 pPcmInfo->u8ConnectFlag = TRUE;
11518 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
11519 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
11520 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
11521 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
11522 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
11523 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
11524 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
11525 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
11526 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
11527 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
11528 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
11529 HAL_AUDIO_PCM_SwDma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
11530
11531 /* init PCM buffer address */
11532 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + SW_DMA_RDR1_BUF_ADDR;
11533 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
11534 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
11535 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
11536
11537 /* apply setting */
11538 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
11539
11540 /* restart */
11541 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11542
11543 /* TODO : force channel6 to SW DMA Reader, it's a hardcode */
11544 HAL_AUDIO_WriteMaskByte(REG_AUDIO_CH6_CFG, 0xFF, 0x8C);
11545
11546 return s32Ret;
11547 }
11548
HAL_AUDIO_PCM_SwDma_Reader1_Close(void)11549 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Close(void)
11550 {
11551 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11552 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11553 MS_S32 s32Ret = 0;
11554 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
11555
11556 if (pPcmInfo->u8ConnectFlag != FALSE)
11557 {
11558 HAL_AUDIO_PCM_SwDma_Reader1_Flush();
11559 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
11560 }
11561
11562 return s32Ret;
11563 }
11564
HAL_AUDIO_PCM_SwDma_Reader1_Start(void)11565 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Start(void)
11566 {
11567 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11568 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11569 MS_S32 s32Ret = 0;
11570 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
11571
11572 if (pPcmInfo->u8StartFlag == FALSE)
11573 {
11574 if (pPCM->u8SettingChangeFlag == TRUE)
11575 {
11576 HAL_AUDIO_PCM_SwDma_Reader1_Apply_Setting();
11577 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
11578 }
11579
11580 /* start engine */
11581 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0002);
11582
11583 pPcmInfo->u8StartFlag = TRUE;
11584 }
11585
11586 return s32Ret;
11587 }
11588
HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)11589 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Stop(void)
11590 {
11591 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11592 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11593 MS_S32 s32Ret = 0;
11594 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
11595
11596 if (pPcmInfo->u8StartFlag != FALSE)
11597 {
11598 /* stop engine */
11599 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0xFFFF, 0x0000);
11600
11601 pPcmInfo->u8StartFlag = FALSE;
11602 }
11603
11604 return s32Ret;
11605 }
11606
HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd,const void * pData)11607 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
11608 {
11609 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11610 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11611 MS_S32 s32Ret = 0;
11612 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11613
11614 if (pData == NULL)
11615 {
11616 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11617 return -A_EFAULT;
11618 }
11619
11620 if (pPcmInfo->u8ConnectFlag == FALSE)
11621 {
11622 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11623 return -A_EPERM;
11624 }
11625
11626 switch(u32Cmd)
11627 {
11628 case AUDIO_PCM_CMD_NONBLOCKING:
11629 {
11630 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
11631
11632 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
11633 {
11634 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
11635 s32Ret = -A_EINVAL;
11636 break;
11637 }
11638
11639 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
11640
11641 break;
11642 }
11643
11644 case AUDIO_PCM_CMD_MULTICH:
11645 {
11646 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
11647
11648 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
11649 {
11650 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
11651 s32Ret = -A_EINVAL;
11652 break;
11653 }
11654
11655 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
11656 {
11657 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
11658 s32Ret = -A_EINVAL;
11659 break;
11660 }
11661
11662 pPcmInfo->u8MultiChFlag = FALSE;
11663
11664 break;
11665 }
11666
11667 case AUDIO_PCM_CMD_MIXING:
11668 {
11669 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
11670
11671 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
11672 {
11673 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
11674 s32Ret = -A_EINVAL;
11675 break;
11676 }
11677
11678 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
11679 {
11680 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
11681 s32Ret = -A_EINVAL;
11682 break;
11683 }
11684
11685 pPcmInfo->u8MixingFlag = FALSE;
11686
11687 break;
11688 }
11689
11690 case AUDIO_PCM_CMD_MIXINGGROUP:
11691 {
11692 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
11693
11694 pPcmInfo->u32MixingGroup = u32MixingGroup;
11695
11696 break;
11697 }
11698
11699 case AUDIO_PCM_CMD_BUFFERDURATION:
11700 {
11701 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
11702
11703 if (u32BufferDuration == 0)
11704 {
11705 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
11706 s32Ret = -A_EINVAL;
11707 break;
11708 }
11709
11710 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
11711 {
11712 pPcmInfo->u32BufferDuration = u32BufferDuration;
11713 pPCM->u8SettingChangeFlag = TRUE;
11714 }
11715
11716 break;
11717 }
11718
11719 case AUDIO_PCM_CMD_CHANNEL:
11720 {
11721 MS_U32 u32Channel = *((MS_U32 *)pData);
11722
11723 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
11724 {
11725 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
11726 return -A_EINVAL;
11727 }
11728
11729 if (pPcmInfo->u32Channel != u32Channel)
11730 {
11731 pPcmInfo->u32Channel = u32Channel;
11732 pPCM->u8SettingChangeFlag = TRUE;
11733 }
11734
11735 break;
11736 }
11737
11738 case AUDIO_PCM_CMD_SAMPLERATE:
11739 {
11740 MS_U32 u32SampleRate = *((MS_U32 *)pData);
11741
11742 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
11743 {
11744 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
11745 return -A_EINVAL;
11746 }
11747
11748 if (pPcmInfo->u32SampleRate != u32SampleRate)
11749 {
11750 pPcmInfo->u32SampleRate = u32SampleRate;
11751 pPCM->u8SettingChangeFlag = TRUE;
11752 }
11753
11754 break;
11755 }
11756
11757 case AUDIO_PCM_CMD_BITWIDTH:
11758 {
11759 MS_U32 u32BitWidth = *((MS_U32 *)pData);
11760
11761 pPcmInfo->u32BitWidth = u32BitWidth;
11762
11763 break;
11764 }
11765
11766 case AUDIO_PCM_CMD_BIGENDIAN:
11767 {
11768 MS_U32 u32BigEndian = *((MS_U32 *)pData);
11769
11770 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
11771 {
11772 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
11773 return -A_EINVAL;
11774 }
11775
11776 pPcmInfo->u32BigEndian = u32BigEndian;
11777
11778 break;
11779 }
11780
11781 case AUDIO_PCM_CMD_TIMESTAMP:
11782 {
11783 MS_U32 u32Timestamp = *((MS_U32 *)pData);
11784
11785 pPcmInfo->u32Timestamp = u32Timestamp;
11786
11787 break;
11788 }
11789
11790 case AUDIO_PCM_CMD_WEIGHTING:
11791 {
11792 MS_U32 u32Weighting = *((MS_U32 *)pData);
11793
11794 if (u32Weighting > 100)
11795 {
11796 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
11797 return -A_EINVAL;
11798 }
11799
11800 pPcmInfo->u32Weighting = u32Weighting;
11801
11802 break;
11803 }
11804
11805 case AUDIO_PCM_CMD_VOLUME:
11806 {
11807 MS_U32 u32Volume = *((MS_U32 *)pData);
11808
11809 if (u32Volume > 100)
11810 {
11811 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
11812 return -A_EINVAL;
11813 }
11814
11815 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
11816
11817 break;
11818 }
11819
11820 case AUDIO_PCM_CMD_MUTE:
11821 {
11822 MS_U32 u32Mute = *((MS_U32*)pData);
11823
11824 if (u32Mute == TRUE)
11825 {
11826 pPcmInfo->u32Volume |= 0x80000000;
11827 }
11828 else if (u32Mute == FALSE)
11829 {
11830 pPcmInfo->u32Volume &= 0x7FFFFFFF;
11831 }
11832 else
11833 {
11834 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
11835 s32Ret = -A_EINVAL;
11836 }
11837 break;
11838 }
11839
11840 default:
11841 {
11842 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
11843 break;
11844 }
11845 }
11846
11847 return s32Ret;
11848 }
11849
HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd,void * pData)11850 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Get(MS_U32 u32Cmd, void *pData)
11851 {
11852 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
11853 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
11854 MS_S32 s32Ret = 0;
11855 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
11856
11857 if (pData == NULL)
11858 {
11859 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
11860 return -A_EFAULT;
11861 }
11862
11863 if (pPcmInfo->u8ConnectFlag == FALSE)
11864 {
11865 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
11866 return -A_EPERM;
11867 }
11868
11869 switch(u32Cmd)
11870 {
11871 case AUDIO_PCM_CMD_ALL:
11872 {
11873 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
11874 MS_U32 u32MinSize = 0;
11875
11876 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
11877 {
11878 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11879 s32Ret = -A_EINVAL;
11880 break;
11881 }
11882 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
11883 {
11884 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
11885 }
11886
11887 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
11888 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
11889 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
11890
11891 break;
11892 }
11893
11894 case AUDIO_PCM_CMD_NONBLOCKING:
11895 {
11896 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
11897 break;
11898 }
11899
11900 case AUDIO_PCM_CMD_MULTICH:
11901 {
11902 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
11903 break;
11904 }
11905
11906 case AUDIO_PCM_CMD_MIXING:
11907 {
11908 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
11909 break;
11910 }
11911
11912 case AUDIO_PCM_CMD_MIXINGGROUP:
11913 {
11914 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
11915 break;
11916 }
11917
11918 case AUDIO_PCM_CMD_BUFFER:
11919 {
11920 /*
11921 * TODO, need better coding
11922 *
11923 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
11924 */
11925 break;
11926 }
11927
11928 case AUDIO_PCM_CMD_BUFFERDURATION:
11929 {
11930 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
11931 break;
11932 }
11933
11934 case AUDIO_PCM_CMD_READPTR:
11935 {
11936 /*
11937 * TODO, need better coding
11938 *
11939 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
11940 */
11941 break;
11942 }
11943
11944 case AUDIO_PCM_CMD_WRITEPTR:
11945 {
11946 /*
11947 * TODO, need better coding
11948 *
11949 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
11950 */
11951 break;
11952 }
11953
11954 case AUDIO_PCM_CMD_CHANNEL:
11955 {
11956 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
11957 break;
11958 }
11959
11960 case AUDIO_PCM_CMD_SAMPLERATE:
11961 {
11962 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
11963 break;
11964 }
11965
11966 case AUDIO_PCM_CMD_BITWIDTH:
11967 {
11968 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
11969 break;
11970 }
11971
11972 case AUDIO_PCM_CMD_BIGENDIAN:
11973 {
11974 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
11975 break;
11976 }
11977
11978 case AUDIO_PCM_CMD_TIMESTAMP:
11979 {
11980 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
11981 break;
11982 }
11983
11984 case AUDIO_PCM_CMD_WEIGHTING:
11985 {
11986 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
11987 break;
11988 }
11989
11990 case AUDIO_PCM_CMD_VOLUME:
11991 {
11992 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
11993 break;
11994 }
11995
11996 case AUDIO_PCM_CMD_BUFFERLEVEL:
11997 {
11998 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0008);
11999 pPcmInfo->u32BufferLevel = HAL_AUDIO_ReadReg(S2M_MBOX_SW_DMA_READER_DDR_Level) * BYTES_IN_MIU_LINE;
12000 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_Ctrl, 0x0008, 0x0000);
12001 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12002 break;
12003 }
12004
12005 case AUDIO_PCM_CMD_MUTE:
12006 {
12007 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12008 break;
12009 }
12010
12011 case AUDIO_PCM_CMD_BUFFERSIZE:
12012 {
12013 MS_U32 u32TargetBufferSize = 0;
12014 MS_U32 u32TargetChannel = 0;
12015 MS_U32 u32TargetBitWidth = 0;
12016
12017 u32TargetChannel = 2;
12018 u32TargetBitWidth = 16;
12019 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12020
12021 *((MS_U32 *)pData) = u32TargetBufferSize;
12022
12023 break;
12024 }
12025
12026 default:
12027 {
12028 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12029 break;
12030 }
12031 }
12032
12033 return s32Ret;
12034 }
12035
HAL_AUDIO_PCM_SwDma_Reader1_Write(const void * pBuf,MS_U32 u32Size)12036 MS_U32 HAL_AUDIO_PCM_SwDma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
12037 {
12038 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
12039 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12040 MS_S8 *pBufTmp = NULL;
12041 MS_U32 u32BufferSize = 0;
12042 MS_U32 u32PcmLevel = 0;
12043 MS_U32 u32RequestSize = 0;
12044 MS_U32 u32RequestSizeTmp = 0;
12045 MS_U32 u32SizeToCopy = 0;
12046 MS_U32 u32WptrOffset = 0;
12047 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
12048
12049 if (pBuf == NULL)
12050 {
12051 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
12052 return 0;
12053 }
12054
12055 if (u32Size == 0)
12056 {
12057 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
12058 return 0;
12059 }
12060
12061 if (pPcmInfo->u8ConnectFlag == FALSE)
12062 {
12063 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12064 return 0;
12065 }
12066
12067 if (pPcmInfo->u8StartFlag == FALSE)
12068 {
12069 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
12070 return 0;
12071 }
12072
12073 pBufTmp = (MS_S8 *)pBuf;
12074
12075 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
12076 if (u32PcmLevel == 0)
12077 {
12078 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
12079 }
12080
12081 u32RequestSize = u32Size;
12082 u32RequestSizeTmp = u32RequestSize;
12083
12084 HAL_AUDIO_PCM_SwDma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
12085
12086 /* copy data to PCM buffer */
12087 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
12088 {
12089 do {
12090 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE) - pPCM->tPcmBufferInfo.pWritePtr;
12091 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
12092
12093 #ifdef MSOS_TYPE_LINUX_KERNEL
12094 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12095 #else
12096 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
12097 #endif
12098
12099 pBufTmp += u32SizeToCopy;
12100 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
12101 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
12102 {
12103 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + SW_DMA_RDR1_BUF_SIZE))
12104 {
12105 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
12106 }
12107 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12108 }
12109
12110 u32RequestSizeTmp -= u32SizeToCopy;
12111 } while (u32RequestSizeTmp > 0);
12112
12113 /* flush MIU */
12114 MsOS_FlushMemory();
12115
12116 /* update write pointers to engine */
12117 u32WptrOffset = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pBuffer;
12118 HAL_AUDIO_WriteMaskReg(M2S_MBOX_SW_DMA_READER_DDR_WtPtr, 0xFFFF, (u32WptrOffset / BYTES_IN_MIU_LINE));
12119
12120 return u32Size;
12121 }
12122
12123 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
12124
12125 return 0;
12126 }
12127
HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)12128 MS_S32 HAL_AUDIO_PCM_SwDma_Reader1_Flush(void)
12129 {
12130 AUDIO_PCM_t *pPCM = &Audio_Pcm_SwDma_Reader1;
12131 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12132 MS_S32 s32Ret = 0;
12133 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
12134
12135 if (pPcmInfo->u8StartFlag == FALSE)
12136 {
12137 HAL_AUDIO_PCM_SwDma_Reader1_Restart();
12138 HAL_AUDIO_PCM_SwDma_Reader1_Stop();
12139 }
12140
12141 return s32Ret;
12142 }
12143 #endif
12144
12145 #if AUDIO_R2_DMA_READER1_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)12146 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting(void)
12147 {
12148 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12149 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12150 MS_U16 u16Val = 0;
12151 MS_U16 u16Synthrate_H = 0;
12152 MS_U16 u16Synthrate_L = 0;
12153 MS_U32 u32TargetBufferSize = 0;
12154 MS_U32 u32TargetChannel = 0;
12155 MS_U32 u32TargetBitWidth = 0;
12156 MS_U32 u32TargetAlignmentSize = 0;
12157 MS_S32 s32Ret = 0;
12158
12159 switch(pPcmInfo->u32SampleRate) {
12160 case 8000:
12161 {
12162 u16Synthrate_H = 0x6978;
12163 u16Synthrate_L = 0x0000;
12164 break;
12165 }
12166
12167 case 11025:
12168 {
12169 u16Synthrate_H = 0x4C87;
12170 u16Synthrate_L = 0xD634;
12171 break;
12172 }
12173
12174 case 12000:
12175 {
12176 u16Synthrate_H = 0x4650;
12177 u16Synthrate_L = 0x0000;
12178 break;
12179 }
12180
12181 case 16000:
12182 {
12183 u16Synthrate_H = 0x34BC;
12184 u16Synthrate_L = 0x0000;
12185 break;
12186 }
12187
12188 case 22050:
12189 {
12190 u16Synthrate_H = 0x2643;
12191 u16Synthrate_L = 0xEB1A;
12192 break;
12193 }
12194
12195 case 24000:
12196 {
12197 u16Synthrate_H = 0x2328;
12198 u16Synthrate_L = 0x0000;
12199 break;
12200 }
12201
12202 case 32000:
12203 {
12204 u16Synthrate_H = 0x1A5E;
12205 u16Synthrate_L = 0x0000;
12206 break;
12207 }
12208
12209 case 44100:
12210 {
12211 u16Synthrate_H = 0x1321;
12212 u16Synthrate_L = 0xF58D;
12213 break;
12214 }
12215
12216 case 48000:
12217 {
12218 u16Synthrate_H = 0x1194;
12219 u16Synthrate_L = 0x0000;
12220 break;
12221 }
12222
12223 case 64000:
12224 {
12225 u16Synthrate_H = 0x0D2F;
12226 u16Synthrate_L = 0x0000;
12227 break;
12228 }
12229
12230 case 88200:
12231 {
12232 u16Synthrate_H = 0x0990;
12233 u16Synthrate_L = 0xFAC6;
12234 break;
12235 }
12236
12237 case 96000:
12238 {
12239 u16Synthrate_H = 0x08CA;
12240 u16Synthrate_L = 0x0000;
12241 break;
12242 }
12243
12244 default:
12245 {
12246 u16Synthrate_H = 0x1194;
12247 u16Synthrate_L = 0x0000;
12248 pPcmInfo->u32SampleRate = 48000;
12249 break;
12250 }
12251 }
12252
12253 /* disable output */
12254 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x7FFF, 0x0000);
12255
12256 /* set synthesizer */
12257 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
12258 HAL_AUR2_WriteMaskReg(R2_DMARDR1_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
12259 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
12260 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0101); /* SYTH1 bit8RIU control, bit0 update */
12261 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0101, 0x0100);
12262
12263 if (pPcmInfo->u8MultiChFlag == TRUE)
12264 {
12265 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12266 u32TargetChannel = 10;
12267 }
12268 else
12269 {
12270 /* stereo = 2 channels */
12271 u32TargetChannel = 2;
12272 }
12273
12274 /* calculate buffer size */
12275 u32TargetBitWidth = 16;
12276 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12277 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12278 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12279 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
12280 {
12281 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate, u32TargetChannel);
12282 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
12283 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12284 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
12285 }
12286
12287 /* set buffer size */
12288 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
12289
12290 /* set overrun & underrun threshold */
12291 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize >> 3)) / BYTES_IN_MIU_LINE));
12292 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
12293
12294 /* set channel mode */
12295 if (pPcmInfo->u8MultiChFlag == TRUE)
12296 {
12297 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12298 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x00);
12299 u16Val = 19; /* MIU burst length = 19 */
12300 u16Val += (1 << 7); /* MIU Step En = 1 */
12301 u16Val += (1 << 15); /* Sync Valid En = 1 */
12302 u16Val += (1 << 8); /* Sync Step Count = 1 */
12303 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
12304 }
12305 else
12306 {
12307 /* Stereo mode : stereo = 2 channels */
12308 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x80, 0x80);
12309 u16Val = 3; /* MIU burst length = 3 */
12310 u16Val += (0 << 7); /* MIU Step En = 0 */
12311 u16Val += (0 << 15); /* Sync Valid En = 0 */
12312 u16Val += (1 << 8); /* Sync Step Count = 1 */
12313 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 7), 0xFFFF, u16Val);
12314 }
12315
12316 /* set 16 Bit mode */
12317 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0860, 0x0020);
12318
12319 pPCM->u8SettingChangeFlag = FALSE;
12320
12321 return s32Ret;
12322 }
12323
HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)12324 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Restart(void)
12325 {
12326 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12327 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12328 MS_S32 s32Ret = 0;
12329
12330 if (pPcmInfo->u8ConnectFlag == FALSE)
12331 {
12332 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12333 return -A_EPERM;
12334 }
12335
12336 /* stop engine */
12337 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0000);
12338
12339 /* clear PCM buffer */
12340 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR1_BUF_SIZE);
12341
12342 /* flush MIU */
12343 MsOS_FlushMemory();
12344
12345 /* initial dlocal buffer */
12346 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x2000);
12347 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x2000, 0x0000);
12348
12349 /* reset engine */
12350 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x1000);
12351 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x1000, 0x0000);
12352
12353 /* start engine */
12354 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0002, 0x0002);
12355
12356 /* reset write pointer */
12357 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12358
12359 /* reset remain size */
12360 pPCM->tPcmBufferInfo.u32RemainSize = 0;
12361
12362 return s32Ret;
12363 }
12364
HAL_AUDIO_PCM_R2Dma_Reader1_Open(void * pData)12365 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Open(void *pData)
12366 {
12367 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12368 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12369 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
12370 MS_U32 u32TargetBufferAddrPa = 0;
12371 MS_U32 u32TargetBufferSize = 0;
12372 MS_U32 u32TargetChannel = 0;
12373 MS_U32 u32TargetBitWidth = 0;
12374 MS_U32 u32TargetAlignmentSize = 0;
12375 MS_S32 s32Ret = 0;
12376 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
12377
12378 if (pData == NULL)
12379 {
12380 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12381 return -A_EFAULT;
12382 }
12383
12384 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12385
12386 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12387 {
12388 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12389 return -A_EINVAL;
12390 }
12391
12392 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
12393 {
12394 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
12395 return -A_EINVAL;
12396 }
12397
12398 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12399 {
12400 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12401 return -A_EINVAL;
12402 }
12403
12404 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12405 {
12406 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12407 return -A_EINVAL;
12408 }
12409
12410 if (pUserPcmInfo->u8CaptureFlag == TRUE)
12411 {
12412 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
12413 return -A_EINVAL;
12414 }
12415
12416 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)
12417 {
12418 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
12419 return -A_EINVAL;
12420 }
12421
12422 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)
12423 {
12424 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
12425 return -A_EINVAL;
12426 }
12427
12428 if (pUserPcmInfo->u8MultiChFlag == TRUE)
12429 {
12430 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
12431 u32TargetChannel = 10;
12432 }
12433 else
12434 {
12435 /* stereo = 2 channels */
12436 u32TargetChannel = 2;
12437 }
12438
12439 /* calculate buffer size */
12440 u32TargetBitWidth = 16;
12441 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
12442 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
12443 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
12444 if (u32TargetBufferSize > R2_DMA_RDR1_BUF_SIZE)
12445 {
12446 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate, u32TargetChannel);
12447 u32TargetBufferSize = R2_DMA_RDR1_BUF_SIZE;
12448 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
12449 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
12450 }
12451
12452 /* fill in settings */
12453 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12454 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
12455 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
12456 pPcmInfo->u8ConnectFlag = TRUE;
12457 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
12458 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
12459 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
12460 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
12461 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
12462 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
12463 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
12464 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
12465 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
12466 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
12467 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
12468 HAL_AUDIO_PCM_R2Dma_Reader1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
12469
12470 /* init DPGA */
12471 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x03, 0x03);
12472 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12473 HAL_AUR2_WriteMaskByte((R2_DMARDR1_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
12474 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
12475 HAL_AUR2_WriteMaskByte(R2_DMARDR1_DPGA_REG_R_CTRL, 0x12, 0x12);
12476
12477 /* init PCM buffer address */
12478 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR1_BUF_ADDR;
12479 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
12480 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
12481 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
12482
12483 /* switch R2_DMA & DPGA control to MCU */
12484 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x8000);
12485 HAL_AUR2_WriteMaskReg(R2_DMARDR1_EN, 0x0001, 0x0001);
12486
12487 /* set PCM buffer address */
12488 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
12489 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
12490
12491 /* apply setting */
12492 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
12493
12494 /* restart */
12495 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
12496
12497 /* TODO : force channel 1~4 to decoder1 when multi-channel output is configured, it's a hardcode */
12498 if (pPcmInfo->u8MultiChFlag == TRUE)
12499 {
12500 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
12501 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
12502 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
12503 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
12504 }
12505
12506 return s32Ret;
12507 }
12508
HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)12509 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Close(void)
12510 {
12511 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12512 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12513 MS_S32 s32Ret = 0;
12514 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
12515
12516 if (pPcmInfo->u8ConnectFlag != FALSE)
12517 {
12518 HAL_AUDIO_PCM_R2Dma_Reader1_Flush();
12519 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
12520 }
12521
12522 /* Switch R2_DMA & DPGA control to R2 */
12523 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x8000, 0x0000);
12524 HAL_AUR2_WriteMaskByte(R2_DMARDR1_EN, 0x01, 0x00);
12525
12526 return s32Ret;
12527 }
12528
HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)12529 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Start(void)
12530 {
12531 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12532 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12533 MS_S32 s32Ret = 0;
12534 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
12535
12536 if (pPcmInfo->u8StartFlag == FALSE)
12537 {
12538 if (pPCM->u8SettingChangeFlag == TRUE)
12539 {
12540 HAL_AUDIO_PCM_R2Dma_Reader1_Apply_Setting();
12541 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
12542 }
12543
12544 /* enable engine's MIU access */
12545 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0001);
12546
12547 pPcmInfo->u8StartFlag = TRUE;
12548 }
12549
12550 return s32Ret;
12551 }
12552
HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)12553 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Stop(void)
12554 {
12555 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12556 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12557 MS_S32 s32Ret = 0;
12558 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
12559
12560 if (pPcmInfo->u8StartFlag != FALSE)
12561 {
12562 /* disable engine's MIU access */
12563 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0001, 0x0000);
12564
12565 pPcmInfo->u8StartFlag = FALSE;
12566 }
12567
12568 return s32Ret;
12569 }
12570
HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd,const void * pData)12571 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Set(MS_U32 u32Cmd, const void *pData)
12572 {
12573 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12574 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12575 MS_S32 s32Ret = 0;
12576 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12577
12578 if (pData == NULL)
12579 {
12580 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12581 return -A_EFAULT;
12582 }
12583
12584 if (pPcmInfo->u8ConnectFlag == FALSE)
12585 {
12586 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12587 return -A_EPERM;
12588 }
12589
12590 switch(u32Cmd)
12591 {
12592 case AUDIO_PCM_CMD_NONBLOCKING:
12593 {
12594 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
12595
12596 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
12597 {
12598 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
12599 s32Ret = -A_EINVAL;
12600 break;
12601 }
12602
12603 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
12604
12605 break;
12606 }
12607
12608 case AUDIO_PCM_CMD_MULTICH:
12609 {
12610 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
12611
12612 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
12613 {
12614 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
12615 s32Ret = -A_EINVAL;
12616 break;
12617 }
12618
12619 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
12620 {
12621 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
12622 s32Ret = -A_EINVAL;
12623 break;
12624 }
12625
12626 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
12627
12628 break;
12629 }
12630
12631 case AUDIO_PCM_CMD_MIXING:
12632 {
12633 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
12634
12635 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
12636 {
12637 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
12638 s32Ret = -A_EINVAL;
12639 break;
12640 }
12641
12642 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
12643 {
12644 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
12645 s32Ret = -A_EINVAL;
12646 break;
12647 }
12648
12649 pPcmInfo->u8MixingFlag = FALSE;
12650
12651 break;
12652 }
12653
12654 case AUDIO_PCM_CMD_MIXINGGROUP:
12655 {
12656 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
12657
12658 pPcmInfo->u32MixingGroup = u32MixingGroup;
12659
12660 break;
12661 }
12662
12663 case AUDIO_PCM_CMD_BUFFERDURATION:
12664 {
12665 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
12666
12667 if (u32BufferDuration == 0)
12668 {
12669 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
12670 s32Ret = -A_EINVAL;
12671 break;
12672 }
12673
12674 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
12675 {
12676 pPcmInfo->u32BufferDuration = u32BufferDuration;
12677 pPCM->u8SettingChangeFlag = TRUE;
12678 }
12679
12680 break;
12681 }
12682
12683 case AUDIO_PCM_CMD_CHANNEL:
12684 {
12685 MS_U32 u32Channel = *((MS_U32 *)pData);
12686
12687 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
12688 {
12689 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
12690 return -A_EINVAL;
12691 }
12692
12693 if (pPcmInfo->u32Channel != u32Channel)
12694 {
12695 pPcmInfo->u32Channel = u32Channel;
12696 pPCM->u8SettingChangeFlag = TRUE;
12697 }
12698
12699 break;
12700 }
12701
12702 case AUDIO_PCM_CMD_SAMPLERATE:
12703 {
12704 MS_U32 u32SampleRate = *((MS_U32 *)pData);
12705
12706 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
12707 {
12708 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
12709 return -A_EINVAL;
12710 }
12711
12712 if (pPcmInfo->u32SampleRate != u32SampleRate)
12713 {
12714 pPcmInfo->u32SampleRate = u32SampleRate;
12715 pPCM->u8SettingChangeFlag = TRUE;
12716 }
12717
12718 break;
12719 }
12720
12721 case AUDIO_PCM_CMD_BITWIDTH:
12722 {
12723 MS_U32 u32BitWidth = *((MS_U32 *)pData);
12724
12725 pPcmInfo->u32BitWidth = u32BitWidth;
12726
12727 break;
12728 }
12729
12730 case AUDIO_PCM_CMD_BIGENDIAN:
12731 {
12732 MS_U32 u32BigEndian = *((MS_U32 *)pData);
12733
12734 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
12735 {
12736 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
12737 return -A_EINVAL;
12738 }
12739
12740 pPcmInfo->u32BigEndian = u32BigEndian;
12741
12742 break;
12743 }
12744
12745 case AUDIO_PCM_CMD_TIMESTAMP:
12746 {
12747 MS_U32 u32Timestamp = *((MS_U32 *)pData);
12748
12749 pPcmInfo->u32Timestamp = u32Timestamp;
12750
12751 break;
12752 }
12753
12754 case AUDIO_PCM_CMD_WEIGHTING:
12755 {
12756 MS_U32 u32Weighting = *((MS_U32 *)pData);
12757
12758 if (u32Weighting > 100)
12759 {
12760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
12761 return -A_EINVAL;
12762 }
12763
12764 pPcmInfo->u32Weighting = u32Weighting;
12765
12766 break;
12767 }
12768
12769 case AUDIO_PCM_CMD_VOLUME:
12770 {
12771 MS_U32 u32Volume = *((MS_U32 *)pData);
12772
12773 if (u32Volume > 100)
12774 {
12775 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
12776 return -A_EINVAL;
12777 }
12778
12779 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
12780
12781 break;
12782 }
12783
12784 case AUDIO_PCM_CMD_MUTE:
12785 {
12786 MS_U32 u32Mute = *((MS_U32*)pData);
12787
12788 if (u32Mute == TRUE)
12789 {
12790 pPcmInfo->u32Volume |= 0x80000000;
12791 }
12792 else if (u32Mute == FALSE)
12793 {
12794 pPcmInfo->u32Volume &= 0x7FFFFFFF;
12795 }
12796 else
12797 {
12798 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
12799 s32Ret = -A_EINVAL;
12800 }
12801 break;
12802 }
12803
12804 default:
12805 {
12806 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
12807 break;
12808 }
12809 }
12810
12811 return s32Ret;
12812 }
12813
HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd,void * pData)12814 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Get(MS_U32 u32Cmd, void *pData)
12815 {
12816 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
12817 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
12818 MS_S32 s32Ret = 0;
12819 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
12820
12821 if (pData == NULL)
12822 {
12823 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
12824 return -A_EFAULT;
12825 }
12826
12827 if (pPcmInfo->u8ConnectFlag == FALSE)
12828 {
12829 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
12830 return -A_EPERM;
12831 }
12832
12833 switch(u32Cmd)
12834 {
12835 case AUDIO_PCM_CMD_ALL:
12836 {
12837 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
12838 MS_U32 u32MinSize = 0;
12839
12840 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
12841 {
12842 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12843 s32Ret = -A_EINVAL;
12844 break;
12845 }
12846 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
12847 {
12848 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
12849 }
12850
12851 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
12852 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
12853 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
12854
12855 break;
12856 }
12857
12858 case AUDIO_PCM_CMD_NONBLOCKING:
12859 {
12860 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
12861 break;
12862 }
12863
12864 case AUDIO_PCM_CMD_MULTICH:
12865 {
12866 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
12867 break;
12868 }
12869
12870 case AUDIO_PCM_CMD_MIXING:
12871 {
12872 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
12873 break;
12874 }
12875
12876 case AUDIO_PCM_CMD_MIXINGGROUP:
12877 {
12878 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
12879 break;
12880 }
12881
12882 case AUDIO_PCM_CMD_BUFFER:
12883 {
12884 /*
12885 * TODO, need better coding
12886 *
12887 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
12888 */
12889 break;
12890 }
12891
12892 case AUDIO_PCM_CMD_BUFFERDURATION:
12893 {
12894 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
12895 break;
12896 }
12897
12898 case AUDIO_PCM_CMD_READPTR:
12899 {
12900 /*
12901 * TODO, need better coding
12902 *
12903 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
12904 */
12905 break;
12906 }
12907
12908 case AUDIO_PCM_CMD_WRITEPTR:
12909 {
12910 /*
12911 * TODO, need better coding
12912 *
12913 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
12914 */
12915 break;
12916 }
12917
12918 case AUDIO_PCM_CMD_CHANNEL:
12919 {
12920 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
12921 break;
12922 }
12923
12924 case AUDIO_PCM_CMD_SAMPLERATE:
12925 {
12926 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
12927 break;
12928 }
12929
12930 case AUDIO_PCM_CMD_BITWIDTH:
12931 {
12932 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
12933 break;
12934 }
12935
12936 case AUDIO_PCM_CMD_BIGENDIAN:
12937 {
12938 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
12939 break;
12940 }
12941
12942 case AUDIO_PCM_CMD_TIMESTAMP:
12943 {
12944 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
12945 break;
12946 }
12947
12948 case AUDIO_PCM_CMD_WEIGHTING:
12949 {
12950 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
12951 break;
12952 }
12953
12954 case AUDIO_PCM_CMD_VOLUME:
12955 {
12956 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
12957 break;
12958 }
12959
12960 case AUDIO_PCM_CMD_BUFFERLEVEL:
12961 {
12962 MS_U32 u32BufferLevel1 = 0;
12963 MS_U32 u32BufferLevel2 = 0;
12964 MS_U32 u32Timeout = 20;
12965
12966 while (u32Timeout > 0)
12967 {
12968 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12969 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
12970
12971 if (u32BufferLevel1 == u32BufferLevel2)
12972 {
12973 break;
12974 }
12975
12976 u32Timeout--;
12977
12978 #ifdef MSOS_TYPE_LINUX_KERNEL
12979 udelay(1);
12980 #else
12981 AUDIO_DELAY1US(1);
12982 #endif
12983 }
12984
12985 if (u32BufferLevel1 != u32BufferLevel2)
12986 {
12987 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
12988 }
12989
12990 pPcmInfo->u32BufferLevel = u32BufferLevel2;
12991 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
12992
12993 break;
12994 }
12995
12996 case AUDIO_PCM_CMD_MUTE:
12997 {
12998 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
12999 break;
13000 }
13001
13002 case AUDIO_PCM_CMD_BUFFERSIZE:
13003 {
13004 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
13005 break;
13006 }
13007
13008 default:
13009 {
13010 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13011 break;
13012 }
13013 }
13014
13015 return s32Ret;
13016 }
13017
HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void * pBuf,MS_U32 u32Size)13018 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader1_Write(const void *pBuf, MS_U32 u32Size)
13019 {
13020 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
13021 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13022 MS_S8 *pBufTmp = NULL;
13023 MS_U32 u32BufferSize = 0;
13024 MS_U32 u32PcmLevel = 0;
13025 MS_U32 u32RequestSize = 0;
13026 MS_U32 u32RequestSizeTmp = 0;
13027 MS_U32 u32SizeToCopy = 0;
13028 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
13029
13030 if (pBuf == NULL)
13031 {
13032 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
13033 return 0;
13034 }
13035
13036 if (u32Size == 0)
13037 {
13038 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
13039 return 0;
13040 }
13041
13042 if (pPcmInfo->u8ConnectFlag == FALSE)
13043 {
13044 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13045 return 0;
13046 }
13047
13048 if (pPcmInfo->u8StartFlag == FALSE)
13049 {
13050 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
13051 return 0;
13052 }
13053
13054 /*
13055 * A patch here!
13056 * to ensure channel 1~4 are configured as decoder1
13057 */
13058 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x80) ||
13059 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x80) ||
13060 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x80) ||
13061 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x80))
13062 {
13063 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x80);
13064 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x80);
13065 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x80);
13066 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x80);
13067 }
13068
13069 pBufTmp = (MS_S8 *)pBuf;
13070
13071 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
13072 if (u32PcmLevel == 0)
13073 {
13074 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
13075 }
13076
13077 u32RequestSize = u32Size;
13078 u32RequestSizeTmp = u32RequestSize;
13079
13080 HAL_AUDIO_PCM_R2Dma_Reader1_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
13081
13082 /* copy data to PCM buffer */
13083 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
13084 {
13085 do {
13086 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
13087 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
13088
13089 #ifdef MSOS_TYPE_LINUX_KERNEL
13090 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
13091 #else
13092 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
13093 #endif
13094
13095 pBufTmp += u32SizeToCopy;
13096 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
13097 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13098 {
13099 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
13100 {
13101 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
13102 }
13103 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13104 }
13105
13106 u32RequestSizeTmp -= u32SizeToCopy;
13107 } while (u32RequestSizeTmp > 0);
13108
13109 /* flush MIU */
13110 MsOS_FlushMemory();
13111
13112 /* update copied size to engine */
13113 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
13114 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
13115 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0400);
13116 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR1_REG_BASE, 0), 0x0400, 0x0000);
13117 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
13118
13119 return u32Size;
13120 }
13121
13122 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
13123
13124 return 0;
13125 }
13126
HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)13127 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader1_Flush(void)
13128 {
13129 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader1;
13130 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13131 MS_S32 s32Ret = 0;
13132 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
13133
13134 if (pPcmInfo->u8StartFlag == FALSE)
13135 {
13136 HAL_AUDIO_PCM_R2Dma_Reader1_Restart();
13137 HAL_AUDIO_PCM_R2Dma_Reader1_Stop();
13138 }
13139
13140 return s32Ret;
13141 }
13142 #endif
13143
13144 #if AUDIO_R2_DMA_READER2_SUPPORT
HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)13145 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting(void)
13146 {
13147 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13148 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13149 MS_U16 u16Val = 0;
13150 MS_U16 u16Synthrate_H = 0;
13151 MS_U16 u16Synthrate_L = 0;
13152 MS_U32 u32TargetBufferSize = 0;
13153 MS_U32 u32TargetChannel = 0;
13154 MS_U32 u32TargetBitWidth = 0;
13155 MS_U32 u32TargetAlignmentSize = 0;
13156 MS_S32 s32Ret = 0;
13157
13158 switch(pPcmInfo->u32SampleRate) {
13159 case 8000:
13160 {
13161 u16Synthrate_H = 0x6978;
13162 u16Synthrate_L = 0x0000;
13163 break;
13164 }
13165
13166 case 11025:
13167 {
13168 u16Synthrate_H = 0x4C87;
13169 u16Synthrate_L = 0xD634;
13170 break;
13171 }
13172
13173 case 12000:
13174 {
13175 u16Synthrate_H = 0x4650;
13176 u16Synthrate_L = 0x0000;
13177 break;
13178 }
13179
13180 case 16000:
13181 {
13182 u16Synthrate_H = 0x34BC;
13183 u16Synthrate_L = 0x0000;
13184 break;
13185 }
13186
13187 case 22050:
13188 {
13189 u16Synthrate_H = 0x2643;
13190 u16Synthrate_L = 0xEB1A;
13191 break;
13192 }
13193
13194 case 24000:
13195 {
13196 u16Synthrate_H = 0x2328;
13197 u16Synthrate_L = 0x0000;
13198 break;
13199 }
13200
13201 case 32000:
13202 {
13203 u16Synthrate_H = 0x1A5E;
13204 u16Synthrate_L = 0x0000;
13205 break;
13206 }
13207
13208 case 44100:
13209 {
13210 u16Synthrate_H = 0x1321;
13211 u16Synthrate_L = 0xF58D;
13212 break;
13213 }
13214
13215 case 48000:
13216 {
13217 u16Synthrate_H = 0x1194;
13218 u16Synthrate_L = 0x0000;
13219 break;
13220 }
13221
13222 case 64000:
13223 {
13224 u16Synthrate_H = 0x0D2F;
13225 u16Synthrate_L = 0x0000;
13226 break;
13227 }
13228
13229 case 88200:
13230 {
13231 u16Synthrate_H = 0x0990;
13232 u16Synthrate_L = 0xFAC6;
13233 break;
13234 }
13235
13236 case 96000:
13237 {
13238 u16Synthrate_H = 0x08CA;
13239 u16Synthrate_L = 0x0000;
13240 break;
13241 }
13242
13243 default:
13244 {
13245 u16Synthrate_H = 0x1194;
13246 u16Synthrate_L = 0x0000;
13247 pPcmInfo->u32SampleRate = 48000;
13248 break;
13249 }
13250 }
13251
13252 /* disable output */
13253 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x7FFF, 0x0000);
13254
13255 /* set synthesizer */
13256 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_L, 0xFFFF, u16Synthrate_L);
13257 HAL_AUR2_WriteMaskReg(R2_DMARDR2_REG_SYNTH_H, 0xFFFF, u16Synthrate_H);
13258 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
13259 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0404); /* SYTH3 bit10 RIU control, bit3 update */
13260 HAL_AUR2_WriteMaskReg(R2_DMARDR_REG_SYNTH_UPDATE, 0x0404, 0x0400);
13261
13262 if (pPcmInfo->u8MultiChFlag == TRUE)
13263 {
13264 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
13265 u32TargetChannel = 10;
13266 }
13267 else
13268 {
13269 /* stereo = 2 channels */
13270 u32TargetChannel = 2;
13271 }
13272
13273 /* calculate buffer size */
13274 u32TargetBitWidth = 16;
13275 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
13276 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
13277 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
13278 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
13279 {
13280 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pPcmInfo->u32BufferDuration, pPcmInfo->u32SampleRate, u32TargetChannel);
13281 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
13282 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
13283 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pPcmInfo->u32BufferDuration);
13284 }
13285
13286 /* set buffer size */
13287 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3), 0xFFFF, (u32TargetBufferSize / BYTES_IN_MIU_LINE)); /* SIZE [15:0] */
13288
13289 /* set overrun & underrun threshold */
13290 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 5), 0xFFFF, ((u32TargetBufferSize - (u32TargetBufferSize>> 3)) / BYTES_IN_MIU_LINE));
13291 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 6), 0xFFFF, ((u32TargetBufferSize >> 3) / BYTES_IN_MIU_LINE));
13292
13293 /* set channel mode */
13294 if (pPcmInfo->u8MultiChFlag == TRUE)
13295 {
13296 /* Multi-Channel mode : 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
13297 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x00);
13298 u16Val = 19; /* MIU burst length = 19 */
13299 u16Val += (1 << 7); /* MIU Step En = 1 */
13300 u16Val += (1 << 15); /* Sync Valid En = 1 */
13301 u16Val += (1 << 8); /* Sync Step Count = 1 */
13302 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
13303 }
13304 else
13305 {
13306 /* Stereo mode : stereo = 2 channels */
13307 HAL_AUR2_WriteMaskByte(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x80, 0x80);
13308 u16Val = 3; /* MIU burst length = 3 */
13309 u16Val += (0 << 7); /* MIU Step En = 0 */
13310 u16Val += (0 << 15); /* Sync Valid En = 0 */
13311 u16Val += (1 << 8); /* Sync Step Count = 1 */
13312 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 7), 0xFFFF, u16Val);
13313 }
13314
13315 /* set 16 Bit mode */
13316 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0860, 0x0020);
13317
13318 pPCM->u8SettingChangeFlag = FALSE;
13319
13320 return s32Ret;
13321 }
13322
HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)13323 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Restart(void)
13324 {
13325 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13326 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13327 MS_S32 s32Ret = 0;
13328
13329 if (pPcmInfo->u8ConnectFlag == FALSE)
13330 {
13331 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13332 return -A_EPERM;
13333 }
13334
13335 /* stop engine */
13336 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0000);
13337
13338 /* clear PCM buffer */
13339 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, R2_DMA_RDR2_BUF_SIZE);
13340
13341 /* flush MIU */
13342 MsOS_FlushMemory();
13343
13344 /* initial dlocal buffer */
13345 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x2000);
13346 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x2000, 0x0000);
13347
13348 /* reset engine */
13349 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x1000);
13350 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x1000, 0x0000);
13351
13352 /* start engine */
13353 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0002, 0x0002);
13354
13355 /* reset write pointer */
13356 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13357
13358 /* reset remain size */
13359 pPCM->tPcmBufferInfo.u32RemainSize = 0;
13360
13361 return s32Ret;
13362 }
13363
HAL_AUDIO_PCM_R2Dma_Reader2_Open(void * pData)13364 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Open(void *pData)
13365 {
13366 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13367 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13368 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
13369 MS_U32 u32TargetBufferAddrPa = 0;
13370 MS_U32 u32TargetBufferSize = 0;
13371 MS_U32 u32TargetChannel = 0;
13372 MS_U32 u32TargetBitWidth = 0;
13373 MS_U32 u32TargetAlignmentSize = 0;
13374 MS_S32 s32Ret = 0;
13375 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
13376
13377 if (pData == NULL)
13378 {
13379 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13380 return -A_EFAULT;
13381 }
13382
13383 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13384
13385 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13386 {
13387 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13388 return -A_EINVAL;
13389 }
13390
13391 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
13392 {
13393 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
13394 return -A_EINVAL;
13395 }
13396
13397 if ((pUserPcmInfo->u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13398 {
13399 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13400 return -A_EINVAL;
13401 }
13402
13403 if ((pUserPcmInfo->u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13404 {
13405 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13406 return -A_EINVAL;
13407 }
13408
13409 if (pUserPcmInfo->u8CaptureFlag == TRUE)
13410 {
13411 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support capture mode!\n", __FUNCTION__);
13412 return -A_EINVAL;
13413 }
13414
13415 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)
13416 {
13417 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
13418 return -A_EINVAL;
13419 }
13420
13421 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)
13422 {
13423 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
13424 return -A_EINVAL;
13425 }
13426
13427 if (pUserPcmInfo->u8MultiChFlag == TRUE)
13428 {
13429 /* 2 + 7.1 = 10 channels (DmxL, DmxR, L, C, R, Ls, Rs, LFE, Lrs, Rrs) */
13430 u32TargetChannel = 10;
13431 }
13432 else
13433 {
13434 /* stereo = 2 channels */
13435 u32TargetChannel = 2;
13436 }
13437
13438 /* calculate buffer size */
13439 u32TargetBitWidth = 16;
13440 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
13441 u32TargetBufferSize = (pUserPcmInfo->u32BufferDuration * pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
13442 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
13443 if (u32TargetBufferSize > R2_DMA_RDR2_BUF_SIZE)
13444 {
13445 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u, channel %u\n", __FUNCTION__, u32TargetBufferSize, pUserPcmInfo->u32BufferDuration, pUserPcmInfo->u32SampleRate, u32TargetChannel);
13446 u32TargetBufferSize = R2_DMA_RDR2_BUF_SIZE;
13447 pUserPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pUserPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
13448 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, pUserPcmInfo->u32BufferDuration);
13449 }
13450
13451 /* fill in settings */
13452 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13453 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
13454 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
13455 pPcmInfo->u8ConnectFlag = TRUE;
13456 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
13457 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
13458 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
13459 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
13460 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
13461 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BUFFERDURATION, &pUserPcmInfo->u32BufferDuration);
13462 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_CHANNEL, &pUserPcmInfo->u32Channel);
13463 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_SAMPLERATE, &pUserPcmInfo->u32SampleRate);
13464 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
13465 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
13466 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
13467 HAL_AUDIO_PCM_R2Dma_Reader2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
13468
13469 /* init DPGA */
13470 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x03, 0x03);
13471 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_L_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
13472 HAL_AUR2_WriteMaskByte((R2_DMARDR2_DPGA_REG_R_CTRL + 1), 0x07,0x07); /* DPGA fading duartion 18ms */
13473 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_L_CTRL, 0x12, 0x12); /* auto mode and fading */
13474 HAL_AUR2_WriteMaskByte(R2_DMARDR2_DPGA_REG_R_CTRL, 0x12, 0x12);
13475
13476 /* init PCM buffer address */
13477 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + R2_DMA_RDR2_BUF_ADDR;
13478 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
13479 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
13480 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
13481
13482 /* switch R2_DMA & DPGA control to MCU */
13483 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x8000);
13484 HAL_AUR2_WriteMaskReg(R2_DMARDR2_EN, 0x0001, 0x0001);
13485
13486 /* set PCM buffer address */
13487 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 1), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) & 0xFFFF)); /* BASE [15:0] */
13488 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 2), 0xFFFF, ((u32TargetBufferAddrPa / BYTES_IN_MIU_LINE) >> 16)); /* BASE [26:16] */
13489
13490 /* apply setting */
13491 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
13492
13493 /* restart */
13494 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
13495
13496 /* TODO : force channel 1~4 to decoder3 when multi-channel output is configured, it's a hardcode */
13497 if (pPcmInfo->u8MultiChFlag == TRUE)
13498 {
13499 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
13500 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
13501 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
13502 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
13503 }
13504
13505 return s32Ret;
13506 }
13507
HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)13508 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Close(void)
13509 {
13510 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13511 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13512 MS_S32 s32Ret = 0;
13513 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
13514
13515 if (pPcmInfo->u8ConnectFlag != FALSE)
13516 {
13517 HAL_AUDIO_PCM_R2Dma_Reader2_Flush();
13518 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
13519 }
13520
13521 /* switch R2_DMA & DPGA control to R2 */
13522 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x8000, 0x0000);
13523 HAL_AUR2_WriteMaskByte(R2_DMARDR2_EN, 0x01, 0x00);
13524
13525 return s32Ret;
13526 }
13527
HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)13528 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Start(void)
13529 {
13530 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13531 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13532 MS_S32 s32Ret = 0;
13533 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
13534
13535 if (pPcmInfo->u8StartFlag == FALSE)
13536 {
13537 if (pPCM->u8SettingChangeFlag == TRUE)
13538 {
13539 HAL_AUDIO_PCM_R2Dma_Reader2_Apply_Setting();
13540 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
13541 }
13542
13543 /* enable engine's MIU access */
13544 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0001);
13545
13546 pPcmInfo->u8StartFlag = TRUE;
13547 }
13548
13549 return s32Ret;
13550 }
13551
HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)13552 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Stop(void)
13553 {
13554 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13555 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13556 MS_S32 s32Ret = 0;
13557 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
13558
13559 if (pPcmInfo->u8StartFlag != FALSE)
13560 {
13561 /* disable engine's MIU access */
13562 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0001, 0x0000);
13563
13564 pPcmInfo->u8StartFlag = FALSE;
13565 }
13566
13567 return s32Ret;
13568 }
13569
HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd,const void * pData)13570 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Set(MS_U32 u32Cmd, const void *pData)
13571 {
13572 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13573 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13574 MS_S32 s32Ret = 0;
13575 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13576
13577 if (pData == NULL)
13578 {
13579 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13580 return -A_EFAULT;
13581 }
13582
13583 if (pPcmInfo->u8ConnectFlag == FALSE)
13584 {
13585 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13586 return -A_EPERM;
13587 }
13588
13589 switch(u32Cmd)
13590 {
13591 case AUDIO_PCM_CMD_NONBLOCKING:
13592 {
13593 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
13594
13595 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
13596 {
13597 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
13598 s32Ret = -A_EINVAL;
13599 break;
13600 }
13601
13602 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
13603
13604 break;
13605 }
13606
13607 case AUDIO_PCM_CMD_MULTICH:
13608 {
13609 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
13610
13611 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
13612 {
13613 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
13614 s32Ret = -A_EINVAL;
13615 break;
13616 }
13617
13618 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
13619 {
13620 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
13621 s32Ret = -A_EINVAL;
13622 break;
13623 }
13624
13625 pPcmInfo->u8MultiChFlag = u8MultiChFlag;
13626
13627 break;
13628 }
13629
13630 case AUDIO_PCM_CMD_MIXING:
13631 {
13632 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
13633
13634 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
13635 {
13636 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
13637 s32Ret = -A_EINVAL;
13638 break;
13639 }
13640
13641 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
13642 {
13643 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
13644 s32Ret = -A_EINVAL;
13645 break;
13646 }
13647
13648 pPcmInfo->u8MixingFlag = FALSE;
13649
13650 break;
13651 }
13652
13653 case AUDIO_PCM_CMD_MIXINGGROUP:
13654 {
13655 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
13656
13657 pPcmInfo->u32MixingGroup = u32MixingGroup;
13658
13659 break;
13660 }
13661
13662 case AUDIO_PCM_CMD_BUFFERDURATION:
13663 {
13664 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
13665
13666 if (u32BufferDuration == 0)
13667 {
13668 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, u32BufferDuration);
13669 s32Ret = -A_EINVAL;
13670 break;
13671 }
13672
13673 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
13674 {
13675 pPcmInfo->u32BufferDuration = u32BufferDuration;
13676 pPCM->u8SettingChangeFlag = TRUE;
13677 }
13678
13679 break;
13680 }
13681
13682 case AUDIO_PCM_CMD_CHANNEL:
13683 {
13684 MS_U32 u32Channel = *((MS_U32 *)pData);
13685
13686 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32Channel, (MS_U32 *)&pPCM->tPcmCaps.u32Channel, (sizeof(pPCM->tPcmCaps.u32Channel) / sizeof(pPCM->tPcmCaps.u32Channel[0]))) < 0)
13687 {
13688 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Channel(%u)!\n", __FUNCTION__, u32Channel);
13689 return -A_EINVAL;
13690 }
13691
13692 if (pPcmInfo->u32Channel != u32Channel)
13693 {
13694 pPcmInfo->u32Channel = u32Channel;
13695 pPCM->u8SettingChangeFlag = TRUE;
13696 }
13697
13698 break;
13699 }
13700
13701 case AUDIO_PCM_CMD_SAMPLERATE:
13702 {
13703 MS_U32 u32SampleRate = *((MS_U32 *)pData);
13704
13705 if (HAL_AUDIO_PCM_Check_U32_Param_Valid(u32SampleRate, (MS_U32 *)&pPCM->tPcmCaps.u32SampleRate, (sizeof(pPCM->tPcmCaps.u32SampleRate) / sizeof(pPCM->tPcmCaps.u32SampleRate[0]))) < 0)
13706 {
13707 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32SampleRate(%u)!\n", __FUNCTION__, u32SampleRate);
13708 return -A_EINVAL;
13709 }
13710
13711 if (pPcmInfo->u32SampleRate != u32SampleRate)
13712 {
13713 pPcmInfo->u32SampleRate = u32SampleRate;
13714 pPCM->u8SettingChangeFlag = TRUE;
13715 }
13716
13717 break;
13718 }
13719
13720 case AUDIO_PCM_CMD_BITWIDTH:
13721 {
13722 MS_U32 u32BitWidth = *((MS_U32 *)pData);
13723
13724 pPcmInfo->u32BitWidth = u32BitWidth;
13725
13726 break;
13727 }
13728
13729 case AUDIO_PCM_CMD_BIGENDIAN:
13730 {
13731 MS_U32 u32BigEndian = *((MS_U32 *)pData);
13732
13733 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
13734 {
13735 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
13736 return -A_EINVAL;
13737 }
13738
13739 pPcmInfo->u32BigEndian = u32BigEndian;
13740
13741 break;
13742 }
13743
13744 case AUDIO_PCM_CMD_TIMESTAMP:
13745 {
13746 MS_U32 u32Timestamp = *((MS_U32 *)pData);
13747
13748 pPcmInfo->u32Timestamp = u32Timestamp;
13749
13750 break;
13751 }
13752
13753 case AUDIO_PCM_CMD_WEIGHTING:
13754 {
13755 MS_U32 u32Weighting = *((MS_U32 *)pData);
13756
13757 if (u32Weighting > 100)
13758 {
13759 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
13760 return -A_EINVAL;
13761 }
13762
13763 pPcmInfo->u32Weighting = u32Weighting;
13764
13765 break;
13766 }
13767
13768 case AUDIO_PCM_CMD_VOLUME:
13769 {
13770 MS_U32 u32Volume = *((MS_U32 *)pData);
13771
13772 if (u32Volume > 100)
13773 {
13774 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
13775 return -A_EINVAL;
13776 }
13777
13778 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
13779
13780 break;
13781 }
13782
13783 case AUDIO_PCM_CMD_MUTE:
13784 {
13785 MS_U32 u32Mute = *((MS_U32*)pData);
13786
13787 if (u32Mute == TRUE)
13788 {
13789 pPcmInfo->u32Volume |= 0x80000000;
13790 }
13791 else if (u32Mute == FALSE)
13792 {
13793 pPcmInfo->u32Volume &= 0x7FFFFFFF;
13794 }
13795 else
13796 {
13797 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
13798 s32Ret = -A_EINVAL;
13799 }
13800 break;
13801 }
13802
13803 default:
13804 {
13805 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
13806 break;
13807 }
13808 }
13809
13810 return s32Ret;
13811 }
13812
HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd,void * pData)13813 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Get(MS_U32 u32Cmd, void *pData)
13814 {
13815 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
13816 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
13817 MS_S32 s32Ret = 0;
13818 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
13819
13820 if (pData == NULL)
13821 {
13822 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
13823 return -A_EFAULT;
13824 }
13825
13826 if (pPcmInfo->u8ConnectFlag == FALSE)
13827 {
13828 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
13829 return -A_EPERM;
13830 }
13831
13832 switch(u32Cmd)
13833 {
13834 case AUDIO_PCM_CMD_ALL:
13835 {
13836 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
13837 MS_U32 u32MinSize = 0;
13838
13839 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
13840 {
13841 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13842 s32Ret = -A_EINVAL;
13843 break;
13844 }
13845 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
13846 {
13847 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
13848 }
13849
13850 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
13851 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
13852 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
13853
13854 break;
13855 }
13856
13857 case AUDIO_PCM_CMD_NONBLOCKING:
13858 {
13859 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
13860 break;
13861 }
13862
13863 case AUDIO_PCM_CMD_MULTICH:
13864 {
13865 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
13866 break;
13867 }
13868
13869 case AUDIO_PCM_CMD_MIXING:
13870 {
13871 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
13872 break;
13873 }
13874
13875 case AUDIO_PCM_CMD_MIXINGGROUP:
13876 {
13877 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
13878 break;
13879 }
13880
13881 case AUDIO_PCM_CMD_BUFFER:
13882 {
13883 /*
13884 * TODO, need better coding
13885 *
13886 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
13887 */
13888 break;
13889 }
13890
13891 case AUDIO_PCM_CMD_BUFFERDURATION:
13892 {
13893 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
13894 break;
13895 }
13896
13897 case AUDIO_PCM_CMD_READPTR:
13898 {
13899 /*
13900 * TODO, need better coding
13901 *
13902 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
13903 */
13904 break;
13905 }
13906
13907 case AUDIO_PCM_CMD_WRITEPTR:
13908 {
13909 /*
13910 * TODO, need better coding
13911 *
13912 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
13913 */
13914 break;
13915 }
13916
13917 case AUDIO_PCM_CMD_CHANNEL:
13918 {
13919 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
13920 break;
13921 }
13922
13923 case AUDIO_PCM_CMD_SAMPLERATE:
13924 {
13925 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
13926 break;
13927 }
13928
13929 case AUDIO_PCM_CMD_BITWIDTH:
13930 {
13931 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
13932 break;
13933 }
13934
13935 case AUDIO_PCM_CMD_BIGENDIAN:
13936 {
13937 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
13938 break;
13939 }
13940
13941 case AUDIO_PCM_CMD_TIMESTAMP:
13942 {
13943 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
13944 break;
13945 }
13946
13947 case AUDIO_PCM_CMD_WEIGHTING:
13948 {
13949 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
13950 break;
13951 }
13952
13953 case AUDIO_PCM_CMD_VOLUME:
13954 {
13955 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
13956 break;
13957 }
13958
13959 case AUDIO_PCM_CMD_BUFFERLEVEL:
13960 {
13961 MS_U32 u32BufferLevel1 = 0;
13962 MS_U32 u32BufferLevel2 = 0;
13963 MS_U32 u32Timeout = 20;
13964
13965 while (u32Timeout > 0)
13966 {
13967 u32BufferLevel1 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
13968 u32BufferLevel2 = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 10))) * BYTES_IN_MIU_LINE;
13969
13970 if (u32BufferLevel1 == u32BufferLevel2)
13971 {
13972 break;
13973 }
13974
13975 u32Timeout--;
13976
13977 #ifdef MSOS_TYPE_LINUX_KERNEL
13978 udelay(1);
13979 #else
13980 AUDIO_DELAY1US(1);
13981 #endif
13982 }
13983
13984 if (u32BufferLevel1 != u32BufferLevel2)
13985 {
13986 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
13987 }
13988
13989 pPcmInfo->u32BufferLevel = u32BufferLevel2;
13990 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
13991
13992 break;
13993 }
13994
13995 case AUDIO_PCM_CMD_MUTE:
13996 {
13997 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
13998 break;
13999 }
14000
14001 case AUDIO_PCM_CMD_BUFFERSIZE:
14002 {
14003 *((MS_U32 *)pData) = (HAL_AUR2_ReadReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 3))) * BYTES_IN_MIU_LINE;
14004 break;
14005 }
14006
14007 default:
14008 {
14009 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14010 break;
14011 }
14012 }
14013
14014 return s32Ret;
14015 }
14016
HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void * pBuf,MS_U32 u32Size)14017 MS_U32 HAL_AUDIO_PCM_R2Dma_Reader2_Write(const void *pBuf, MS_U32 u32Size)
14018 {
14019 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
14020 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14021 MS_S8 *pBufTmp = NULL;
14022 MS_U32 u32BufferSize = 0;
14023 MS_U32 u32PcmLevel = 0;
14024 MS_U32 u32RequestSize = 0;
14025 MS_U32 u32RequestSizeTmp = 0;
14026 MS_U32 u32SizeToCopy = 0;
14027 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14028
14029 if (pBuf == NULL)
14030 {
14031 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14032 return 0;
14033 }
14034
14035 if (u32Size == 0)
14036 {
14037 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14038 return 0;
14039 }
14040
14041 if (pPcmInfo->u8ConnectFlag == FALSE)
14042 {
14043 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14044 return 0;
14045 }
14046
14047 if (pPcmInfo->u8StartFlag == FALSE)
14048 {
14049 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
14050 return 0;
14051 }
14052
14053 /*
14054 * A patch here!
14055 * to ensure channel 1~4 are configured as decoder3
14056 */
14057 if ((HAL_AUDIO_ReadByte(REG_AUDIO_CH1_CFG) != 0x82) ||
14058 (HAL_AUDIO_ReadByte(REG_AUDIO_CH2_CFG) != 0x82) ||
14059 (HAL_AUDIO_ReadByte(REG_AUDIO_CH3_CFG) != 0x82) ||
14060 (HAL_AUDIO_ReadByte(REG_AUDIO_CH4_CFG) != 0x82))
14061 {
14062 HAL_AUDIO_WriteByte(REG_AUDIO_CH1_CFG, 0x82);
14063 HAL_AUDIO_WriteByte(REG_AUDIO_CH2_CFG, 0x82);
14064 HAL_AUDIO_WriteByte(REG_AUDIO_CH3_CFG, 0x82);
14065 HAL_AUDIO_WriteByte(REG_AUDIO_CH4_CFG, 0x82);
14066 }
14067
14068 pBufTmp = (MS_S8 *)pBuf;
14069
14070 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14071 if (u32PcmLevel == 0)
14072 {
14073 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14074 }
14075
14076 u32RequestSize = u32Size;
14077 u32RequestSizeTmp = u32RequestSize;
14078
14079 HAL_AUDIO_PCM_R2Dma_Reader2_Get(AUDIO_PCM_CMD_BUFFERSIZE, &u32BufferSize);
14080
14081 /* copy data to PCM buffer */
14082 if ((u32PcmLevel + u32RequestSize) <= u32BufferSize)
14083 {
14084 do {
14085 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pWritePtr;
14086 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14087
14088 #ifdef MSOS_TYPE_LINUX_KERNEL
14089 memcpy_toio((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
14090 #else
14091 memcpy((void *)pPCM->tPcmBufferInfo.pWritePtr, (void *)pBufTmp, u32SizeToCopy);
14092 #endif
14093
14094 pBufTmp += u32SizeToCopy;
14095 pPCM->tPcmBufferInfo.pWritePtr += u32SizeToCopy;
14096 if (pPCM->tPcmBufferInfo.pWritePtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14097 {
14098 if (pPCM->tPcmBufferInfo.pWritePtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14099 {
14100 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14101 }
14102 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14103 }
14104
14105 u32RequestSizeTmp -= u32SizeToCopy;
14106 } while (u32RequestSizeTmp > 0);
14107
14108 /* flush MIU */
14109 MsOS_FlushMemory();
14110
14111 /* update copied size to engine */
14112 u32RequestSize += pPCM->tPcmBufferInfo.u32RemainSize;
14113 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 4), 0xFFFF, (u32RequestSize / BYTES_IN_MIU_LINE));
14114 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0400);
14115 HAL_AUR2_WriteMaskReg(AUDIO_R2_DMA_RDER_CFG_REG(R2_DMARDR2_REG_BASE, 0), 0x0400, 0x0000);
14116 pPCM->tPcmBufferInfo.u32RemainSize = u32RequestSize % BYTES_IN_MIU_LINE;
14117
14118 return u32Size;
14119 }
14120
14121 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
14122
14123 return 0;
14124 }
14125
HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)14126 MS_S32 HAL_AUDIO_PCM_R2Dma_Reader2_Flush(void)
14127 {
14128 AUDIO_PCM_t *pPCM = &Audio_Pcm_R2Dma_Reader2;
14129 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14130 MS_S32 s32Ret = 0;
14131 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14132
14133 if (pPcmInfo->u8StartFlag == FALSE)
14134 {
14135 HAL_AUDIO_PCM_R2Dma_Reader2_Restart();
14136 HAL_AUDIO_PCM_R2Dma_Reader2_Stop();
14137 }
14138
14139 return s32Ret;
14140 }
14141 #endif
14142
14143 #if AUDIO_PCM_CAPTURE1_SUPPORT
HAL_AUDIO_PCM_Capture1_Restart(void)14144 MS_S32 HAL_AUDIO_PCM_Capture1_Restart(void)
14145 {
14146 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14147 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14148 MS_U32 u32WritePtrOffset = 0;
14149 MS_U32 u32TimeoutCounter = 0;
14150 MS_S32 s32Ret = 0;
14151
14152 if (pPcmInfo->u8ConnectFlag == FALSE)
14153 {
14154 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14155 return -A_EPERM;
14156 }
14157
14158 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, 0x0000);
14159
14160 do {
14161 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14162
14163 if (u32WritePtrOffset != 0)
14164 {
14165 #ifdef MSOS_TYPE_LINUX_KERNEL
14166 udelay(50);
14167 #else
14168 AUDIO_DELAY1US(50);
14169 #endif
14170 u32TimeoutCounter++;
14171 }
14172 else
14173 {
14174 break;
14175 }
14176 } while (u32TimeoutCounter < 10000);
14177
14178 /* clear PCM buffer */
14179 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE1_BUF_SIZE);
14180
14181 /* flush MIU */
14182 MsOS_FlushMemory();
14183
14184 /* reset PCM capture1 read & write pointer */
14185 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14186 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14187 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, 0x0000);
14188
14189 return s32Ret;
14190 }
14191
HAL_AUDIO_PCM_Capture1_Open(void * pData)14192 MS_S32 HAL_AUDIO_PCM_Capture1_Open(void *pData)
14193 {
14194 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14195 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14196 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
14197 MS_U32 u32TargetBufferAddrPa = 0;
14198 MS_S32 s32Ret = 0;
14199 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
14200
14201 if (pData == NULL)
14202 {
14203 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14204 return -A_EFAULT;
14205 }
14206
14207 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14208
14209 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14210 {
14211 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14212 return -A_EINVAL;
14213 }
14214
14215 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
14216 {
14217 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
14218 return -A_EINVAL;
14219 }
14220
14221 if (pUserPcmInfo->u8MultiChFlag == TRUE)
14222 {
14223 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14224 return -A_EINVAL;
14225 }
14226
14227 if (pUserPcmInfo->u8MixingFlag == TRUE)
14228 {
14229 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14230 return -A_EINVAL;
14231 }
14232
14233 if (pUserPcmInfo->u8CaptureFlag != TRUE)
14234 {
14235 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
14236 return -A_EINVAL;
14237 }
14238
14239 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)
14240 {
14241 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
14242 return -A_EINVAL;
14243 }
14244
14245 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)
14246 {
14247 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
14248 return -A_EINVAL;
14249 }
14250
14251 /* fill in settings */
14252 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14253 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
14254 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
14255 pPcmInfo->u8ConnectFlag = TRUE;
14256 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
14257 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
14258 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
14259 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
14260 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
14261 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
14262 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
14263 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
14264 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
14265 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
14266 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
14267 HAL_AUDIO_PCM_Capture1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
14268
14269 /* init PCM buffer address */
14270 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE1_BUF_ADDR;
14271 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
14272 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14273 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14274
14275 /* restart */
14276 HAL_AUDIO_PCM_Capture1_Restart();
14277
14278 return s32Ret;
14279 }
14280
HAL_AUDIO_PCM_Capture1_Close(void)14281 MS_S32 HAL_AUDIO_PCM_Capture1_Close(void)
14282 {
14283 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14284 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14285 MS_S32 s32Ret = 0;
14286 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
14287
14288 if (pPcmInfo->u8ConnectFlag != FALSE)
14289 {
14290 HAL_AUDIO_PCM_Capture1_Flush();
14291 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14292 }
14293
14294 return s32Ret;
14295 }
14296
HAL_AUDIO_PCM_Capture1_Start(void)14297 MS_S32 HAL_AUDIO_PCM_Capture1_Start(void)
14298 {
14299 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14300 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14301 MS_U32 u32BufferSize = 0;
14302 MS_S32 s32Ret = 0;
14303 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
14304
14305 if (pPcmInfo->u8StartFlag == FALSE)
14306 {
14307 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14308 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
14309
14310 pPcmInfo->u8StartFlag = TRUE;
14311 }
14312
14313 return s32Ret;
14314 }
14315
HAL_AUDIO_PCM_Capture1_Stop(void)14316 MS_S32 HAL_AUDIO_PCM_Capture1_Stop(void)
14317 {
14318 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14319 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14320 MS_S32 s32Ret = 0;
14321 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
14322
14323 if (pPcmInfo->u8StartFlag != FALSE)
14324 {
14325 /* TODO, there is no such control in DSP */
14326
14327 pPcmInfo->u8StartFlag = FALSE;
14328 }
14329
14330 return s32Ret;
14331 }
14332
HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd,const void * pData)14333 MS_S32 HAL_AUDIO_PCM_Capture1_Set(MS_U32 u32Cmd, const void *pData)
14334 {
14335 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14336 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14337 MS_S32 s32Ret = 0;
14338 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14339
14340 if (pData == NULL)
14341 {
14342 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14343 return -A_EFAULT;
14344 }
14345
14346 if (pPcmInfo->u8ConnectFlag == FALSE)
14347 {
14348 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14349 return -A_EPERM;
14350 }
14351
14352 switch(u32Cmd)
14353 {
14354 case AUDIO_PCM_CMD_NONBLOCKING:
14355 {
14356 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
14357
14358 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
14359 {
14360 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
14361 s32Ret = -A_EINVAL;
14362 break;
14363 }
14364
14365 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
14366
14367 break;
14368 }
14369
14370 case AUDIO_PCM_CMD_MULTICH:
14371 {
14372 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
14373
14374 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
14375 {
14376 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
14377 s32Ret = -A_EINVAL;
14378 break;
14379 }
14380
14381 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
14382 {
14383 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14384 s32Ret = -A_EINVAL;
14385 break;
14386 }
14387
14388 pPcmInfo->u8MultiChFlag = FALSE;
14389
14390 break;
14391 }
14392
14393 case AUDIO_PCM_CMD_MIXING:
14394 {
14395 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
14396
14397 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
14398 {
14399 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
14400 s32Ret = -A_EINVAL;
14401 break;
14402 }
14403
14404 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
14405 {
14406 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14407 s32Ret = -A_EINVAL;
14408 break;
14409 }
14410
14411 pPcmInfo->u8MixingFlag = FALSE;
14412
14413 break;
14414 }
14415
14416 case AUDIO_PCM_CMD_MIXINGGROUP:
14417 {
14418 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
14419
14420 pPcmInfo->u32MixingGroup = u32MixingGroup;
14421
14422 break;
14423 }
14424
14425 case AUDIO_PCM_CMD_BUFFERDURATION:
14426 {
14427 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
14428 s32Ret = -A_EPERM;
14429
14430 break;
14431 }
14432
14433 case AUDIO_PCM_CMD_CHANNEL:
14434 {
14435 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
14436 s32Ret = -A_EPERM;
14437
14438 break;
14439 }
14440
14441 case AUDIO_PCM_CMD_SAMPLERATE:
14442 {
14443 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
14444 s32Ret = -A_EPERM;
14445
14446 break;
14447 }
14448
14449 case AUDIO_PCM_CMD_BITWIDTH:
14450 {
14451 MS_U32 u32BitWidth = *((MS_U32 *)pData);
14452
14453 pPcmInfo->u32BitWidth = u32BitWidth;
14454
14455 break;
14456 }
14457
14458 case AUDIO_PCM_CMD_BIGENDIAN:
14459 {
14460 MS_U32 u32BigEndian = *((MS_U32 *)pData);
14461
14462 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
14463 {
14464 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
14465 return -A_EINVAL;
14466 }
14467
14468 pPcmInfo->u32BigEndian = u32BigEndian;
14469
14470 break;
14471 }
14472
14473 case AUDIO_PCM_CMD_TIMESTAMP:
14474 {
14475 MS_U32 u32Timestamp = *((MS_U32 *)pData);
14476
14477 pPcmInfo->u32Timestamp = u32Timestamp;
14478
14479 break;
14480 }
14481
14482 case AUDIO_PCM_CMD_WEIGHTING:
14483 {
14484 MS_U32 u32Weighting = *((MS_U32 *)pData);
14485
14486 if (u32Weighting > 100)
14487 {
14488 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
14489 return -A_EINVAL;
14490 }
14491
14492 pPcmInfo->u32Weighting = u32Weighting;
14493
14494 break;
14495 }
14496
14497 case AUDIO_PCM_CMD_VOLUME:
14498 {
14499 MS_U32 u32Volume = *((MS_U32 *)pData);
14500
14501 if (u32Volume > 100)
14502 {
14503 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
14504 return -A_EINVAL;
14505 }
14506
14507 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
14508
14509 break;
14510 }
14511
14512 case AUDIO_PCM_CMD_MUTE:
14513 {
14514 MS_U32 u32Mute = *((MS_U32*)pData);
14515
14516 if (u32Mute == TRUE)
14517 {
14518 pPcmInfo->u32Volume |= 0x80000000;
14519 }
14520 else if (u32Mute == FALSE)
14521 {
14522 pPcmInfo->u32Volume &= 0x7FFFFFFF;
14523 }
14524 else
14525 {
14526 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
14527 s32Ret = -A_EINVAL;
14528 }
14529 break;
14530 }
14531
14532 default:
14533 {
14534 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14535 break;
14536 }
14537 }
14538
14539 return s32Ret;
14540 }
14541
HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd,void * pData)14542 MS_S32 HAL_AUDIO_PCM_Capture1_Get(MS_U32 u32Cmd, void *pData)
14543 {
14544 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14545 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14546 MS_S32 s32Ret = 0;
14547 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
14548
14549 if (pData == NULL)
14550 {
14551 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14552 return -A_EFAULT;
14553 }
14554
14555 if (pPcmInfo->u8ConnectFlag == FALSE)
14556 {
14557 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14558 return -A_EPERM;
14559 }
14560
14561 switch(u32Cmd)
14562 {
14563 case AUDIO_PCM_CMD_ALL:
14564 {
14565 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14566 MS_U32 u32MinSize = 0;
14567
14568 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14569 {
14570 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14571 s32Ret = -A_EINVAL;
14572 break;
14573 }
14574 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
14575 {
14576 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14577 }
14578
14579 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
14580 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
14581 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
14582
14583 break;
14584 }
14585
14586 case AUDIO_PCM_CMD_NONBLOCKING:
14587 {
14588 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
14589 break;
14590 }
14591
14592 case AUDIO_PCM_CMD_MULTICH:
14593 {
14594 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
14595 break;
14596 }
14597
14598 case AUDIO_PCM_CMD_MIXING:
14599 {
14600 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
14601 break;
14602 }
14603
14604 case AUDIO_PCM_CMD_MIXINGGROUP:
14605 {
14606 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
14607 break;
14608 }
14609
14610 case AUDIO_PCM_CMD_BUFFER:
14611 {
14612 /*
14613 * TODO, need better coding
14614 *
14615 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
14616 */
14617 break;
14618 }
14619
14620 case AUDIO_PCM_CMD_BUFFERDURATION:
14621 {
14622 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
14623 break;
14624 }
14625
14626 case AUDIO_PCM_CMD_READPTR:
14627 {
14628 /*
14629 * TODO, need better coding
14630 *
14631 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
14632 */
14633 break;
14634 }
14635
14636 case AUDIO_PCM_CMD_WRITEPTR:
14637 {
14638 /*
14639 * TODO, need better coding
14640 *
14641 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
14642 */
14643 break;
14644 }
14645
14646 case AUDIO_PCM_CMD_CHANNEL:
14647 {
14648 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
14649 break;
14650 }
14651
14652 case AUDIO_PCM_CMD_SAMPLERATE:
14653 {
14654 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
14655 break;
14656 }
14657
14658 case AUDIO_PCM_CMD_BITWIDTH:
14659 {
14660 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
14661 break;
14662 }
14663
14664 case AUDIO_PCM_CMD_BIGENDIAN:
14665 {
14666 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
14667 break;
14668 }
14669
14670 case AUDIO_PCM_CMD_TIMESTAMP:
14671 {
14672 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
14673 break;
14674 }
14675
14676 case AUDIO_PCM_CMD_WEIGHTING:
14677 {
14678 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
14679 break;
14680 }
14681
14682 case AUDIO_PCM_CMD_VOLUME:
14683 {
14684 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
14685 break;
14686 }
14687
14688 case AUDIO_PCM_CMD_BUFFERLEVEL:
14689 {
14690 MS_U32 u32WritePtrOffset = 0;
14691 MS_U32 u32BufferSize = 0;
14692 MS_S32 s32PcmLevel = 0;
14693
14694 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14695 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
14696
14697 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
14698 if (s32PcmLevel < 0)
14699 {
14700 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14701 s32PcmLevel += u32BufferSize;
14702 }
14703
14704 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
14705 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
14706
14707 break;
14708 }
14709
14710 case AUDIO_PCM_CMD_MUTE:
14711 {
14712 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
14713 break;
14714 }
14715
14716 case AUDIO_PCM_CMD_BUFFERSIZE:
14717 {
14718 *((MS_U32 *)pData) = PCM_CAPTURE1_BUF_SIZE;
14719
14720 break;
14721 }
14722
14723 default:
14724 {
14725 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
14726 break;
14727 }
14728 }
14729
14730 return s32Ret;
14731 }
14732
HAL_AUDIO_PCM_Capture1_Read(void * pBuf,MS_U32 u32Size)14733 MS_U32 HAL_AUDIO_PCM_Capture1_Read(void *pBuf, MS_U32 u32Size)
14734 {
14735 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14736 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14737 MS_S8 *pBufTmp = NULL;
14738 MS_U32 u32BufferSize = 0;
14739 MS_U32 u32PcmLevel = 0;
14740 MS_U32 u32RequestSize = 0;
14741 MS_U32 u32RequestSizeTmp = 0;
14742 MS_U32 u32SizeToCopy = 0;
14743 MS_U32 u32RptrOffset = 0;
14744 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
14745
14746 if (pBuf == NULL)
14747 {
14748 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
14749 return 0;
14750 }
14751
14752 if (u32Size == 0)
14753 {
14754 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
14755 return 0;
14756 }
14757
14758 if (pPcmInfo->u8ConnectFlag == FALSE)
14759 {
14760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14761 return 0;
14762 }
14763
14764 if (pPcmInfo->u8StartFlag == FALSE)
14765 {
14766 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
14767 return 0;
14768 }
14769
14770 pBufTmp = (MS_S8 *)pBuf;
14771
14772 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
14773 HAL_AUDIO_PCM_Capture1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
14774 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE1_BUF_UNIT))
14775 {
14776 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
14777
14778 u32PcmLevel = 0;
14779 HAL_AUDIO_PCM_Capture1_Stop();
14780 HAL_AUDIO_PCM_Capture1_Restart();
14781 HAL_AUDIO_PCM_Capture1_Start();
14782 }
14783
14784 u32RequestSize = u32Size;
14785 u32RequestSizeTmp = u32RequestSize;
14786
14787 /* copy data from PCM buffer */
14788 if (u32PcmLevel >= u32RequestSize)
14789 {
14790 do {
14791 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
14792 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
14793
14794 #ifdef MSOS_TYPE_LINUX_KERNEL
14795 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14796 #else
14797 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
14798 #endif
14799
14800 pBufTmp += u32SizeToCopy;
14801 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
14802 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14803 {
14804 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
14805 {
14806 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
14807 }
14808 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14809 }
14810
14811 u32RequestSizeTmp -= u32SizeToCopy;
14812 } while (u32RequestSizeTmp > 0);
14813
14814 /* flush MIU */
14815 MsOS_FlushMemory();
14816
14817 /* update read pointer to engine */
14818 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
14819 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
14820
14821 return u32Size;
14822 }
14823
14824 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
14825
14826 return 0;
14827 }
14828
HAL_AUDIO_PCM_Capture1_Flush(void)14829 MS_S32 HAL_AUDIO_PCM_Capture1_Flush(void)
14830 {
14831 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture1;
14832 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14833 MS_S32 s32Ret = 0;
14834 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
14835
14836 if (pPcmInfo->u8StartFlag == FALSE)
14837 {
14838 HAL_AUDIO_PCM_Capture1_Restart();
14839 HAL_AUDIO_PCM_Capture1_Stop();
14840 }
14841
14842 return s32Ret;
14843 }
14844 #endif
14845
14846 #if AUDIO_PCM_CAPTURE2_SUPPORT
HAL_AUDIO_PCM_Capture2_Restart(void)14847 MS_S32 HAL_AUDIO_PCM_Capture2_Restart(void)
14848 {
14849 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14850 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14851 MS_U32 u32WritePtrOffset = 0;
14852 MS_U32 u32TimeoutCounter = 0;
14853 MS_S32 s32Ret = 0;
14854
14855 if (pPcmInfo->u8ConnectFlag == FALSE)
14856 {
14857 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
14858 return -A_EPERM;
14859 }
14860
14861 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, 0x0000);
14862
14863 do {
14864 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
14865
14866 if (u32WritePtrOffset != 0)
14867 {
14868 #ifdef MSOS_TYPE_LINUX_KERNEL
14869 udelay(50);
14870 #else
14871 AUDIO_DELAY1US(50);
14872 #endif
14873 u32TimeoutCounter++;
14874 }
14875 else
14876 {
14877 break;
14878 }
14879 } while (u32TimeoutCounter < 10000);
14880
14881 /* clear PCM buffer */
14882 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, PCM_CAPTURE2_BUF_SIZE);
14883
14884 /* flush MIU */
14885 MsOS_FlushMemory();
14886
14887 /* reset PCM capture1 read & write pointer */
14888 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14889 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14890 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, 0x0000);
14891
14892 return s32Ret;
14893 }
14894
HAL_AUDIO_PCM_Capture2_Open(void * pData)14895 MS_S32 HAL_AUDIO_PCM_Capture2_Open(void *pData)
14896 {
14897 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14898 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14899 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
14900 MS_U32 u32TargetBufferAddrPa = 0;
14901 MS_S32 s32Ret = 0;
14902 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
14903
14904 if (pData == NULL)
14905 {
14906 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
14907 return -A_EFAULT;
14908 }
14909
14910 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
14911
14912 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
14913 {
14914 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
14915 return -A_EINVAL;
14916 }
14917
14918 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
14919 {
14920 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
14921 return -A_EINVAL;
14922 }
14923
14924 if (pUserPcmInfo->u8MultiChFlag == TRUE)
14925 {
14926 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
14927 return -A_EINVAL;
14928 }
14929
14930 if (pUserPcmInfo->u8MixingFlag == TRUE)
14931 {
14932 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
14933 return -A_EINVAL;
14934 }
14935
14936 if (pUserPcmInfo->u8CaptureFlag != TRUE)
14937 {
14938 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
14939 return -A_EINVAL;
14940 }
14941
14942 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)
14943 {
14944 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, pUserPcmInfo->u32Channel);
14945 return -A_EINVAL;
14946 }
14947
14948 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)
14949 {
14950 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, pUserPcmInfo->u32SampleRate);
14951 return -A_EINVAL;
14952 }
14953
14954 /* fill in settings */
14955 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14956 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
14957 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
14958 pPcmInfo->u8ConnectFlag = TRUE;
14959 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
14960 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
14961 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
14962 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
14963 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
14964 pPcmInfo->u32BufferDuration = ((PCM_CAPTURE2_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
14965 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
14966 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;
14967 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
14968 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
14969 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
14970 HAL_AUDIO_PCM_Capture2_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
14971
14972 /* init PCM buffer address */
14973 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + PCM_CAPTURE2_BUF_ADDR;
14974 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
14975 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
14976 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
14977
14978 /* restart */
14979 HAL_AUDIO_PCM_Capture2_Restart();
14980
14981 return s32Ret;
14982 }
14983
HAL_AUDIO_PCM_Capture2_Close(void)14984 MS_S32 HAL_AUDIO_PCM_Capture2_Close(void)
14985 {
14986 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
14987 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
14988 MS_S32 s32Ret = 0;
14989 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
14990
14991 if (pPcmInfo->u8ConnectFlag != FALSE)
14992 {
14993 HAL_AUDIO_PCM_Capture2_Flush();
14994 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
14995 }
14996
14997 return s32Ret;
14998 }
14999
HAL_AUDIO_PCM_Capture2_Start(void)15000 MS_S32 HAL_AUDIO_PCM_Capture2_Start(void)
15001 {
15002 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15003 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15004 MS_U32 u32BufferSize = 0;
15005 MS_S32 s32Ret = 0;
15006 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
15007
15008 if (pPcmInfo->u8StartFlag == FALSE)
15009 {
15010 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15011 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_Size, (u32BufferSize / BYTES_IN_MIU_LINE));
15012
15013 pPcmInfo->u8StartFlag = TRUE;
15014 }
15015
15016 return s32Ret;
15017 }
15018
HAL_AUDIO_PCM_Capture2_Stop(void)15019 MS_S32 HAL_AUDIO_PCM_Capture2_Stop(void)
15020 {
15021 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15022 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15023 MS_S32 s32Ret = 0;
15024 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
15025
15026 if (pPcmInfo->u8StartFlag != FALSE)
15027 {
15028 /* TODO, there is no such control in DSP */
15029
15030 pPcmInfo->u8StartFlag = FALSE;
15031 }
15032
15033 return s32Ret;
15034 }
15035
HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd,const void * pData)15036 MS_S32 HAL_AUDIO_PCM_Capture2_Set(MS_U32 u32Cmd, const void *pData)
15037 {
15038 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15039 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15040 MS_S32 s32Ret = 0;
15041 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15042
15043 if (pData == NULL)
15044 {
15045 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15046 return -A_EFAULT;
15047 }
15048
15049 if (pPcmInfo->u8ConnectFlag == FALSE)
15050 {
15051 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15052 return -A_EPERM;
15053 }
15054
15055 switch(u32Cmd)
15056 {
15057 case AUDIO_PCM_CMD_NONBLOCKING:
15058 {
15059 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
15060
15061 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
15062 {
15063 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
15064 s32Ret = -A_EINVAL;
15065 break;
15066 }
15067
15068 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
15069
15070 break;
15071 }
15072
15073 case AUDIO_PCM_CMD_MULTICH:
15074 {
15075 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
15076
15077 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
15078 {
15079 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
15080 s32Ret = -A_EINVAL;
15081 break;
15082 }
15083
15084 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
15085 {
15086 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
15087 s32Ret = -A_EINVAL;
15088 break;
15089 }
15090
15091 pPcmInfo->u8MultiChFlag = FALSE;
15092
15093 break;
15094 }
15095
15096 case AUDIO_PCM_CMD_MIXING:
15097 {
15098 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
15099
15100 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
15101 {
15102 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
15103 s32Ret = -A_EINVAL;
15104 break;
15105 }
15106
15107 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
15108 {
15109 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
15110 s32Ret = -A_EINVAL;
15111 break;
15112 }
15113
15114 pPcmInfo->u8MixingFlag = FALSE;
15115
15116 break;
15117 }
15118
15119 case AUDIO_PCM_CMD_MIXINGGROUP:
15120 {
15121 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
15122
15123 pPcmInfo->u32MixingGroup = u32MixingGroup;
15124
15125 break;
15126 }
15127
15128 case AUDIO_PCM_CMD_BUFFERDURATION:
15129 {
15130 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure buffer duration!\n", __FUNCTION__);
15131 s32Ret = -A_EPERM;
15132
15133 break;
15134 }
15135
15136 case AUDIO_PCM_CMD_CHANNEL:
15137 {
15138 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
15139 s32Ret = -A_EPERM;
15140
15141 break;
15142 }
15143
15144 case AUDIO_PCM_CMD_SAMPLERATE:
15145 {
15146 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
15147 s32Ret = -A_EPERM;
15148
15149 break;
15150 }
15151
15152 case AUDIO_PCM_CMD_BITWIDTH:
15153 {
15154 MS_U32 u32BitWidth = *((MS_U32 *)pData);
15155
15156 pPcmInfo->u32BitWidth = u32BitWidth;
15157
15158 break;
15159 }
15160
15161 case AUDIO_PCM_CMD_BIGENDIAN:
15162 {
15163 MS_U32 u32BigEndian = *((MS_U32 *)pData);
15164
15165 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
15166 {
15167 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, u32BigEndian);
15168 return -A_EINVAL;
15169 }
15170
15171 pPcmInfo->u32BigEndian = u32BigEndian;
15172
15173 break;
15174 }
15175
15176 case AUDIO_PCM_CMD_TIMESTAMP:
15177 {
15178 MS_U32 u32Timestamp = *((MS_U32 *)pData);
15179
15180 pPcmInfo->u32Timestamp = u32Timestamp;
15181
15182 break;
15183 }
15184
15185 case AUDIO_PCM_CMD_WEIGHTING:
15186 {
15187 MS_U32 u32Weighting = *((MS_U32 *)pData);
15188
15189 if (u32Weighting > 100)
15190 {
15191 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
15192 return -A_EINVAL;
15193 }
15194
15195 pPcmInfo->u32Weighting = u32Weighting;
15196
15197 break;
15198 }
15199
15200 case AUDIO_PCM_CMD_VOLUME:
15201 {
15202 MS_U32 u32Volume = *((MS_U32 *)pData);
15203
15204 if (u32Volume > 100)
15205 {
15206 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
15207 return -A_EINVAL;
15208 }
15209
15210 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
15211
15212 break;
15213 }
15214
15215 case AUDIO_PCM_CMD_MUTE:
15216 {
15217 MS_U32 u32Mute = *((MS_U32*)pData);
15218
15219 if (u32Mute == TRUE)
15220 {
15221 pPcmInfo->u32Volume |= 0x80000000;
15222 }
15223 else if (u32Mute == FALSE)
15224 {
15225 pPcmInfo->u32Volume &= 0x7FFFFFFF;
15226 }
15227 else
15228 {
15229 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, u32Mute);
15230 s32Ret = -A_EINVAL;
15231 }
15232 break;
15233 }
15234
15235 default:
15236 {
15237 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
15238 break;
15239 }
15240 }
15241
15242 return s32Ret;
15243 }
15244
HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd,void * pData)15245 MS_S32 HAL_AUDIO_PCM_Capture2_Get(MS_U32 u32Cmd, void *pData)
15246 {
15247 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15248 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15249 MS_S32 s32Ret = 0;
15250 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15251
15252 if (pData == NULL)
15253 {
15254 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15255 return -A_EFAULT;
15256 }
15257
15258 if (pPcmInfo->u8ConnectFlag == FALSE)
15259 {
15260 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15261 return -A_EPERM;
15262 }
15263
15264 switch(u32Cmd)
15265 {
15266 case AUDIO_PCM_CMD_ALL:
15267 {
15268 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
15269 MS_U32 u32MinSize = 0;
15270
15271 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
15272 {
15273 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
15274 s32Ret = -A_EINVAL;
15275 break;
15276 }
15277 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
15278 {
15279 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
15280 }
15281
15282 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
15283 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
15284 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
15285
15286 break;
15287 }
15288
15289 case AUDIO_PCM_CMD_NONBLOCKING:
15290 {
15291 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
15292 break;
15293 }
15294
15295 case AUDIO_PCM_CMD_MULTICH:
15296 {
15297 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
15298 break;
15299 }
15300
15301 case AUDIO_PCM_CMD_MIXING:
15302 {
15303 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
15304 break;
15305 }
15306
15307 case AUDIO_PCM_CMD_MIXINGGROUP:
15308 {
15309 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
15310 break;
15311 }
15312
15313 case AUDIO_PCM_CMD_BUFFER:
15314 {
15315 /*
15316 * TODO, need better coding
15317 *
15318 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
15319 */
15320 break;
15321 }
15322
15323 case AUDIO_PCM_CMD_BUFFERDURATION:
15324 {
15325 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
15326 break;
15327 }
15328
15329 case AUDIO_PCM_CMD_READPTR:
15330 {
15331 /*
15332 * TODO, need better coding
15333 *
15334 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
15335 */
15336 break;
15337 }
15338
15339 case AUDIO_PCM_CMD_WRITEPTR:
15340 {
15341 /*
15342 * TODO, need better coding
15343 *
15344 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
15345 */
15346 break;
15347 }
15348
15349 case AUDIO_PCM_CMD_CHANNEL:
15350 {
15351 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
15352 break;
15353 }
15354
15355 case AUDIO_PCM_CMD_SAMPLERATE:
15356 {
15357 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
15358 break;
15359 }
15360
15361 case AUDIO_PCM_CMD_BITWIDTH:
15362 {
15363 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
15364 break;
15365 }
15366
15367 case AUDIO_PCM_CMD_BIGENDIAN:
15368 {
15369 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
15370 break;
15371 }
15372
15373 case AUDIO_PCM_CMD_TIMESTAMP:
15374 {
15375 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
15376 break;
15377 }
15378
15379 case AUDIO_PCM_CMD_WEIGHTING:
15380 {
15381 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
15382 break;
15383 }
15384
15385 case AUDIO_PCM_CMD_VOLUME:
15386 {
15387 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
15388 break;
15389 }
15390
15391 case AUDIO_PCM_CMD_BUFFERLEVEL:
15392 {
15393 MS_U32 u32WritePtrOffset = 0;
15394 MS_U32 u32BufferSize = 0;
15395 MS_S32 s32PcmLevel = 0;
15396
15397 u32WritePtrOffset = HAL_AUDIO_ReadReg(S2M_MBOX_PCM_CAPTURE2_DDR_WrPtr) * BYTES_IN_MIU_LINE;
15398 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer + u32WritePtrOffset;
15399
15400 s32PcmLevel = pPCM->tPcmBufferInfo.pWritePtr - pPCM->tPcmBufferInfo.pReadPtr;
15401 if (s32PcmLevel < 0)
15402 {
15403 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15404 s32PcmLevel += u32BufferSize;
15405 }
15406
15407 pPcmInfo->u32BufferLevel = (MS_U32)s32PcmLevel;
15408 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
15409
15410 break;
15411 }
15412
15413 case AUDIO_PCM_CMD_MUTE:
15414 {
15415 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
15416 break;
15417 }
15418
15419 case AUDIO_PCM_CMD_BUFFERSIZE:
15420 {
15421 *((MS_U32 *)pData) = PCM_CAPTURE2_BUF_SIZE;
15422
15423 break;
15424 }
15425
15426 default:
15427 {
15428 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, u32Cmd);
15429 break;
15430 }
15431 }
15432
15433 return s32Ret;
15434 }
15435
HAL_AUDIO_PCM_Capture2_Read(void * pBuf,MS_U32 u32Size)15436 MS_U32 HAL_AUDIO_PCM_Capture2_Read(void *pBuf, MS_U32 u32Size)
15437 {
15438 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15439 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15440 MS_S8 *pBufTmp = NULL;
15441 MS_U32 u32BufferSize = 0;
15442 MS_U32 u32PcmLevel = 0;
15443 MS_U32 u32RequestSize = 0;
15444 MS_U32 u32RequestSizeTmp = 0;
15445 MS_U32 u32SizeToCopy = 0;
15446 MS_U32 u32RptrOffset = 0;
15447 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
15448
15449 if (pBuf == NULL)
15450 {
15451 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
15452 return 0;
15453 }
15454
15455 if (u32Size == 0)
15456 {
15457 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
15458 return 0;
15459 }
15460
15461 if (pPcmInfo->u8ConnectFlag == FALSE)
15462 {
15463 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15464 return 0;
15465 }
15466
15467 if (pPcmInfo->u8StartFlag == FALSE)
15468 {
15469 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
15470 return 0;
15471 }
15472
15473 pBufTmp = (MS_S8 *)pBuf;
15474
15475 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
15476 HAL_AUDIO_PCM_Capture2_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
15477 if (u32PcmLevel >= (u32BufferSize - PCM_CAPTURE2_BUF_UNIT))
15478 {
15479 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer full!\n", __FUNCTION__);
15480
15481 u32PcmLevel = 0;
15482 HAL_AUDIO_PCM_Capture2_Stop();
15483 HAL_AUDIO_PCM_Capture2_Restart();
15484 HAL_AUDIO_PCM_Capture2_Start();
15485 }
15486
15487 u32RequestSize = u32Size;
15488 u32RequestSizeTmp = u32RequestSize;
15489
15490 /* copy data from PCM buffer */
15491 if (u32PcmLevel >= u32RequestSize)
15492 {
15493 do {
15494 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
15495 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
15496
15497 #ifdef MSOS_TYPE_LINUX_KERNEL
15498 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15499 #else
15500 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
15501 #endif
15502
15503 pBufTmp += u32SizeToCopy;
15504 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
15505 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15506 {
15507 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
15508 {
15509 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
15510 }
15511 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15512 }
15513
15514 u32RequestSizeTmp -= u32SizeToCopy;
15515 } while (u32RequestSizeTmp > 0);
15516
15517 /* flush MIU */
15518 MsOS_FlushMemory();
15519
15520 /* update read pointer to engine */
15521 u32RptrOffset = pPCM->tPcmBufferInfo.pReadPtr - pPCM->tPcmBufferInfo.pBuffer;
15522 HAL_AUDIO_WriteReg(M2S_MBOX_PCM_CAPTURE2_DDR_RdPtr, (u32RptrOffset / BYTES_IN_MIU_LINE));
15523
15524 return u32Size;
15525 }
15526
15527 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! PCM buffer empty!\n", __FUNCTION__);
15528
15529 return 0;
15530 }
15531
HAL_AUDIO_PCM_Capture2_Flush(void)15532 MS_S32 HAL_AUDIO_PCM_Capture2_Flush(void)
15533 {
15534 AUDIO_PCM_t *pPCM = &Audio_Pcm_Capture2;
15535 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15536 MS_S32 s32Ret = 0;
15537 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
15538
15539 if (pPcmInfo->u8StartFlag == FALSE)
15540 {
15541 HAL_AUDIO_PCM_Capture2_Restart();
15542 HAL_AUDIO_PCM_Capture2_Stop();
15543 }
15544
15545 return s32Ret;
15546 }
15547 #endif
15548
15549 #if AUDIO_HW_DMA_WRITER1_SUPPORT
HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)15550 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Restart(void)
15551 {
15552 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15553 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15554 //MS_U32 u32WritePtrOffset = 0;
15555 //MS_U32 u32TimeoutCounter = 0;
15556 MS_S32 s32Ret = 0;
15557
15558 if (pPcmInfo->u8ConnectFlag == FALSE)
15559 {
15560 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15561 return -A_EPERM;
15562 }
15563
15564 /* clear PCM buffer */
15565 memset((void *)pPCM->tPcmBufferInfo.pBuffer, 0x00, HW_DMA_WTR1_BUF_SIZE);
15566
15567 /* flush MIU */
15568 MsOS_FlushMemory();
15569 return s32Ret;
15570 }
15571
HAL_AUDIO_PCM_HwDma_Writer1_Open(void * pData)15572 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Open(void *pData)
15573 {
15574 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15575 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15576 AUDIO_PCM_INFO_t *pUserPcmInfo = NULL;
15577 MS_U32 u32TargetBufferAddrPa = 0;
15578 MS_U32 u32TargetBufferSize = 0;
15579 MS_U32 u32TargetChannel = 0;
15580 MS_U32 u32TargetBitWidth = 0;
15581 MS_U32 u32TargetAlignmentSize = 0;
15582 MS_S32 s32Ret = 0;
15583 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Open %s\n", __FUNCTION__, pPCM->u8Name);
15584
15585 if (pData == NULL)
15586 {
15587 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15588 return -A_EFAULT;
15589 }
15590
15591 pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
15592
15593 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
15594 {
15595 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
15596 return -A_EINVAL;
15597 }
15598
15599 if (pUserPcmInfo->u32StructSize != sizeof(AUDIO_PCM_INFO_t))
15600 {
15601 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The size of PCM Info mismatch(%u, %u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32StructSize, sizeof(AUDIO_PCM_INFO_t));
15602 return -A_EINVAL;
15603 }
15604
15605 if (pUserPcmInfo->u8MultiChFlag == TRUE)
15606 {
15607 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
15608 return -A_EINVAL;
15609 }
15610
15611 if (pUserPcmInfo->u8MixingFlag == TRUE)
15612 {
15613 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
15614 return -A_EINVAL;
15615 }
15616
15617 if (pUserPcmInfo->u8CaptureFlag != TRUE)
15618 {
15619 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support playback mode!\n", __FUNCTION__);
15620 return -A_EINVAL;
15621 }
15622
15623 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)
15624 {
15625 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support channel(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32Channel);
15626 return -A_EINVAL;
15627 }
15628
15629 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)
15630 {
15631 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support sample rate(%u)!\n", __FUNCTION__, (unsigned int)pUserPcmInfo->u32SampleRate);
15632 return -A_EINVAL;
15633 }
15634
15635 /* fill in settings */
15636 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
15637 pPcmInfo->u32StructVersion = AUDIO_PCM_INFO_VERSION;
15638 pPcmInfo->u32StructSize = sizeof(AUDIO_PCM_INFO_t);
15639 pPcmInfo->u8ConnectFlag = TRUE;
15640 snprintf((char *)pPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
15641 snprintf((char *)pUserPcmInfo->u8Name, AUDIO_COMMON_PCM_IO_NAME_LENGTH, "%s", (char *)pPCM->u8Name);
15642 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_NONBLOCKING, &pUserPcmInfo->u8NonBlockingFlag);
15643 pPcmInfo->u8MultiChFlag = pUserPcmInfo->u8MultiChFlag;
15644 pPcmInfo->u8MixingFlag = pUserPcmInfo->u8MixingFlag;
15645 pPcmInfo->u32BufferDuration = ((HW_DMA_WTR1_BUF_SIZE * 1000) / (pUserPcmInfo->u32Channel * 2)) / pUserPcmInfo->u32SampleRate;
15646 pPcmInfo->u32Channel = pUserPcmInfo->u32Channel;
15647 pPcmInfo->u32SampleRate = pUserPcmInfo->u32SampleRate;;
15648 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BITWIDTH, &pUserPcmInfo->u32BitWidth);
15649 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_BIGENDIAN, &pUserPcmInfo->u32BigEndian);
15650 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_WEIGHTING, &pUserPcmInfo->u32Weighting);
15651 HAL_AUDIO_PCM_HwDma_Writer1_Set(AUDIO_PCM_CMD_VOLUME, &pUserPcmInfo->u32Volume);
15652
15653 /* init PCM buffer address */
15654 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + HW_DMA_WTR1_BUF_ADDR;
15655 pPCM->tPcmBufferInfo.pBuffer = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
15656 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
15657 pPCM->tPcmBufferInfo.pWritePtr = pPCM->tPcmBufferInfo.pBuffer;
15658
15659 /* set PCM buffer address */
15660 HAL_AUDIO_AbsWriteReg(NewDMAwriter_ctrl, 0x0);
15661 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Lo, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE) & 0xFFFF);
15662 HAL_AUDIO_AbsWriteReg(NewDMAwriter_BaseAddress_Hi, (u32TargetBufferAddrPa/BYTES_IN_MIU_LINE>>16) & 0xFFFF);
15663
15664 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x80, 0x80);
15665 HAL_AUDIO_WriteMaskReg(M2S_MBOX_HW_DMA_WRITER1_CTRL, 0x0F, M2S_MBOX_GET_Raw);
15666
15667 /* calculate buffer size */
15668 u32TargetChannel = 2;
15669 u32TargetBitWidth = 16;
15670 u32TargetAlignmentSize = u32TargetChannel * (u32TargetBitWidth / 8) * BYTES_IN_MIU_LINE;
15671 u32TargetBufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)) / 1000;
15672 AUDIO_DO_ALIGNMENT(u32TargetBufferSize, u32TargetAlignmentSize);
15673 if (u32TargetBufferSize > HW_DMA_WTR1_BUF_SIZE)
15674 {
15675 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Too large buffer size(%u) is required! Please check the settings: duration %u, sample rate %u\n", __FUNCTION__, (unsigned int)u32TargetBufferSize, (unsigned int)pPcmInfo->u32BufferDuration, (unsigned int)pPcmInfo->u32SampleRate);
15676 u32TargetBufferSize = HW_DMA_WTR1_BUF_SIZE;
15677 pPcmInfo->u32BufferDuration = ((u32TargetBufferSize * 1000) / (pPcmInfo->u32SampleRate * u32TargetChannel * (u32TargetBitWidth / 8)));
15678 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Force duration to %u, which is the maximun value\n", __FUNCTION__, (unsigned int)pPcmInfo->u32BufferDuration);
15679 }
15680
15681 /* set buffer size */
15682 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_size, 0xFFFF, u32TargetBufferSize / BYTES_IN_MIU_LINE);
15683 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_DRAM_underrun_threshold, 0xFFFF, 0x00012); //setting : DMA Reader Underrun Thr
15684
15685 /* Reset and Start DMA Writer */
15686 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x800B); //SW reset & enable DMA reader, MIU request
15687 AUDIO_DELAY1US(1);
15688 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0xFFFF, 0x000B); //SW reset & enable DMA reader, MIU request
15689
15690 /* restart */
15691 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
15692
15693 return s32Ret;
15694 }
15695
HAL_AUDIO_PCM_HwDma_Writer1_Close(void)15696 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Close(void)
15697 {
15698 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15699 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15700 MS_S32 s32Ret = 0;
15701 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Close %s\n", __FUNCTION__, pPCM->u8Name);
15702
15703 if (pPcmInfo->u8ConnectFlag != FALSE)
15704 {
15705 HAL_AUDIO_PCM_HwDma_Writer1_Flush();
15706 memset((void *)pPcmInfo, 0x00, sizeof(AUDIO_PCM_INFO_t));
15707 }
15708
15709 return s32Ret;
15710 }
15711
HAL_AUDIO_PCM_HwDma_Writer1_Start(void)15712 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Start(void)
15713 {
15714 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15715 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15716 //MS_U32 u32BufferSize = 0;
15717 MS_S32 s32Ret = 0;
15718 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Start %s\n", __FUNCTION__, pPCM->u8Name);
15719
15720 if (pPcmInfo->u8StartFlag == FALSE)
15721 {
15722 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0001);
15723 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0002);
15724
15725 pPcmInfo->u8StartFlag = TRUE;
15726 }
15727
15728 return s32Ret;
15729 }
15730
HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)15731 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Stop(void)
15732 {
15733 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15734 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15735 MS_S32 s32Ret = 0;
15736 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Stop %s\n", __FUNCTION__, pPCM->u8Name);
15737
15738 if (pPcmInfo->u8StartFlag != FALSE)
15739 {
15740 /* TODO, there is no such control in DSP */
15741
15742 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0001, 0x0000);
15743 HAL_AUDIO_AbsWriteMaskReg(NewDMAwriter_ctrl, 0x0002, 0x0000);
15744
15745 pPcmInfo->u8StartFlag = FALSE;
15746 }
15747
15748 return s32Ret;
15749 }
15750
HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd,const void * pData)15751 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Set(MS_U32 u32Cmd, const void *pData)
15752 {
15753 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15754 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15755 MS_S32 s32Ret = 0;
15756 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Set command %u to %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15757
15758 if (pData == NULL)
15759 {
15760 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15761 return -A_EFAULT;
15762 }
15763
15764 if (pPcmInfo->u8ConnectFlag == FALSE)
15765 {
15766 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15767 return -A_EPERM;
15768 }
15769
15770 switch(u32Cmd)
15771 {
15772 case AUDIO_PCM_CMD_NONBLOCKING:
15773 {
15774 MS_U8 u8NonBlockingFlag = *((MS_U8 *)pData);
15775
15776 if ((u8NonBlockingFlag != TRUE) && (u8NonBlockingFlag != FALSE))
15777 {
15778 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8NonBlockingFlag(%d)!\n", __FUNCTION__, u8NonBlockingFlag);
15779 s32Ret = -A_EINVAL;
15780 break;
15781 }
15782
15783 pPcmInfo->u8NonBlockingFlag = u8NonBlockingFlag;
15784
15785 break;
15786 }
15787
15788 case AUDIO_PCM_CMD_MULTICH:
15789 {
15790 MS_U8 u8MultiChFlag = *((MS_U8 *)pData);
15791
15792 if ((u8MultiChFlag != TRUE) && (u8MultiChFlag != FALSE))
15793 {
15794 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MultiChFlag(%d)!\n", __FUNCTION__, u8MultiChFlag);
15795 s32Ret = -A_EINVAL;
15796 break;
15797 }
15798
15799 if ((u8MultiChFlag == TRUE) && (pPCM->tPcmCaps.u8MultiChFlag != TRUE))
15800 {
15801 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support Multi-Channel!\n", __FUNCTION__);
15802 s32Ret = -A_EINVAL;
15803 break;
15804 }
15805
15806 pPcmInfo->u8MultiChFlag = FALSE;
15807
15808 break;
15809 }
15810
15811 case AUDIO_PCM_CMD_MIXING:
15812 {
15813 MS_U8 u8MixingFlag = *((MS_U8 *)pData);
15814
15815 if ((u8MixingFlag != TRUE) && (u8MixingFlag != FALSE))
15816 {
15817 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u8MixingFlag(%d)!\n", __FUNCTION__, u8MixingFlag);
15818 s32Ret = -A_EINVAL;
15819 break;
15820 }
15821
15822 if ((u8MixingFlag == TRUE) && (pPCM->tPcmCaps.u8MixingFlag != TRUE))
15823 {
15824 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not support mixing mode!\n", __FUNCTION__);
15825 s32Ret = -A_EINVAL;
15826 break;
15827 }
15828
15829 pPcmInfo->u8MixingFlag = FALSE;
15830
15831 break;
15832 }
15833
15834 case AUDIO_PCM_CMD_MIXINGGROUP:
15835 {
15836 MS_U32 u32MixingGroup = *((MS_U32 *)pData);
15837
15838 pPcmInfo->u32MixingGroup = u32MixingGroup;
15839
15840 break;
15841 }
15842
15843 case AUDIO_PCM_CMD_BUFFERDURATION:
15844 {
15845 MS_U32 u32BufferDuration = *((MS_U32 *)pData);
15846
15847 if (u32BufferDuration == 0)
15848 {
15849 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BufferDuration(%u)!\n", __FUNCTION__, (unsigned int)u32BufferDuration);
15850 s32Ret = -A_EINVAL;
15851 break;
15852 }
15853
15854 if (pPcmInfo->u32BufferDuration != u32BufferDuration)
15855 {
15856 pPcmInfo->u32BufferDuration = u32BufferDuration;
15857 pPCM->u8SettingChangeFlag = TRUE;
15858 }
15859
15860 break;
15861 }
15862
15863 case AUDIO_PCM_CMD_CHANNEL:
15864 {
15865 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure channel!\n", __FUNCTION__);
15866 s32Ret = -A_EPERM;
15867
15868 break;
15869 }
15870
15871 case AUDIO_PCM_CMD_SAMPLERATE:
15872 {
15873 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! Not support to configure sample rate!\n", __FUNCTION__);
15874 s32Ret = -A_EPERM;
15875
15876 break;
15877 }
15878
15879 case AUDIO_PCM_CMD_BITWIDTH:
15880 {
15881 MS_U32 u32BitWidth = *((MS_U32 *)pData);
15882
15883 pPcmInfo->u32BitWidth = u32BitWidth;
15884
15885 break;
15886 }
15887
15888 case AUDIO_PCM_CMD_BIGENDIAN:
15889 {
15890 MS_U32 u32BigEndian = *((MS_U32 *)pData);
15891
15892 if ((u32BigEndian != TRUE) && (u32BigEndian != FALSE))
15893 {
15894 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32BigEndian(%u)!\n", __FUNCTION__, (unsigned int)u32BigEndian);
15895 return -A_EINVAL;
15896 }
15897
15898 pPcmInfo->u32BigEndian = u32BigEndian;
15899
15900 break;
15901 }
15902
15903 case AUDIO_PCM_CMD_TIMESTAMP:
15904 {
15905 MS_U32 u32Timestamp = *((MS_U32 *)pData);
15906
15907 pPcmInfo->u32Timestamp = u32Timestamp;
15908
15909 break;
15910 }
15911
15912 case AUDIO_PCM_CMD_WEIGHTING:
15913 {
15914 MS_U32 u32Weighting = *((MS_U32 *)pData);
15915
15916 if (u32Weighting > 100)
15917 {
15918 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Weighting(%u)!\n", __FUNCTION__, u32Weighting);
15919 return -A_EINVAL;
15920 }
15921
15922 pPcmInfo->u32Weighting = u32Weighting;
15923
15924 break;
15925 }
15926
15927 case AUDIO_PCM_CMD_VOLUME:
15928 {
15929 MS_U32 u32Volume = *((MS_U32 *)pData);
15930
15931 if (u32Volume > 100)
15932 {
15933 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid u32Volume(%u)!\n", __FUNCTION__, u32Volume);
15934 return -A_EINVAL;
15935 }
15936
15937 pPcmInfo->u32Volume = u32Volume | (pPcmInfo->u32Volume & 0x80000000);
15938
15939 break;
15940 }
15941
15942 case AUDIO_PCM_CMD_MUTE:
15943 {
15944 MS_U32 u32Mute = *((MS_U32*)pData);
15945
15946 if (u32Mute == TRUE)
15947 {
15948 pPcmInfo->u32Volume |= 0x80000000;
15949 }
15950 else if (u32Mute == FALSE)
15951 {
15952 pPcmInfo->u32Volume &= 0x7FFFFFFF;
15953 }
15954 else
15955 {
15956 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! invalid Invalid mute command(%u)!\n", __FUNCTION__, (unsigned int)u32Mute);
15957 s32Ret = -A_EINVAL;
15958 }
15959 break;
15960 }
15961
15962 default:
15963 {
15964 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
15965 break;
15966 }
15967 }
15968
15969 return s32Ret;
15970 }
15971
HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd,void * pData)15972 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Get(MS_U32 u32Cmd, void *pData)
15973 {
15974 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
15975 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
15976 MS_S32 s32Ret = 0;
15977 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Get command %u from %s\n", __FUNCTION__, u32Cmd, pPCM->u8Name);
15978
15979 if (pData == NULL)
15980 {
15981 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
15982 return -A_EFAULT;
15983 }
15984
15985 if (pPcmInfo->u8ConnectFlag == FALSE)
15986 {
15987 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
15988 return -A_EPERM;
15989 }
15990
15991 switch(u32Cmd)
15992 {
15993 case AUDIO_PCM_CMD_ALL:
15994 {
15995 AUDIO_PCM_INFO_t *pUserPcmInfo = (AUDIO_PCM_INFO_t *)pData;
15996 MS_U32 u32MinSize = 0;
15997
15998 if ((pUserPcmInfo->u32StructVersion & AUDIO_MAJOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MAJOR_VERSION_MASK))
15999 {
16000 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
16001 s32Ret = -A_EINVAL;
16002 break;
16003 }
16004 else if ((pUserPcmInfo->u32StructVersion & AUDIO_MINOR_VERSION_MASK) != (AUDIO_PCM_INFO_VERSION & AUDIO_MINOR_VERSION_MASK))
16005 {
16006 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! The version of PCM Info mismatch(0x%08X, 0x%08X)!\n", __FUNCTION__, pUserPcmInfo->u32StructVersion, AUDIO_PCM_INFO_VERSION);
16007 }
16008
16009 u32MinSize = sizeof(AUDIO_PCM_INFO_t);
16010 u32MinSize = (pUserPcmInfo->u32StructSize >= u32MinSize) ? u32MinSize : pUserPcmInfo->u32StructSize;
16011 memcpy((void *)pUserPcmInfo, (void *)pPcmInfo, u32MinSize);
16012
16013 break;
16014 }
16015
16016 case AUDIO_PCM_CMD_NONBLOCKING:
16017 {
16018 *((MS_U8 *)pData) = pPcmInfo->u8NonBlockingFlag;
16019 break;
16020 }
16021
16022 case AUDIO_PCM_CMD_MULTICH:
16023 {
16024 *((MS_U8 *)pData) = pPcmInfo->u8MultiChFlag;
16025 break;
16026 }
16027
16028 case AUDIO_PCM_CMD_MIXING:
16029 {
16030 *((MS_U8 *)pData) = pPcmInfo->u8MixingFlag;
16031 break;
16032 }
16033
16034 case AUDIO_PCM_CMD_MIXINGGROUP:
16035 {
16036 *((MS_U32 *)pData) = pPcmInfo->u32MixingGroup;
16037 break;
16038 }
16039
16040 case AUDIO_PCM_CMD_BUFFER:
16041 {
16042 /*
16043 * TODO, need better coding
16044 *
16045 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pBuffer;
16046 */
16047 break;
16048 }
16049
16050 case AUDIO_PCM_CMD_BUFFERDURATION:
16051 {
16052 *((MS_U32 *)pData) = pPcmInfo->u32BufferDuration;
16053 break;
16054 }
16055
16056 case AUDIO_PCM_CMD_READPTR:
16057 {
16058 /*
16059 * TODO, need better coding
16060 *
16061 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pReadPtr;
16062 */
16063 break;
16064 }
16065
16066 case AUDIO_PCM_CMD_WRITEPTR:
16067 {
16068 /*
16069 * TODO, need better coding
16070 *
16071 * *((MS_S8 *)pData) = pPCM->tPcmBufferInfo.pWritePtr;
16072 */
16073 break;
16074 }
16075
16076 case AUDIO_PCM_CMD_CHANNEL:
16077 {
16078 *((MS_U32 *)pData) = pPcmInfo->u32Channel;
16079 break;
16080 }
16081
16082 case AUDIO_PCM_CMD_SAMPLERATE:
16083 {
16084 *((MS_U32 *)pData) = pPcmInfo->u32SampleRate;
16085 break;
16086 }
16087
16088 case AUDIO_PCM_CMD_BITWIDTH:
16089 {
16090 *((MS_U32 *)pData) = pPcmInfo->u32BitWidth;
16091 break;
16092 }
16093
16094 case AUDIO_PCM_CMD_BIGENDIAN:
16095 {
16096 *((MS_U32 *)pData) = pPcmInfo->u32BigEndian;
16097 break;
16098 }
16099
16100 case AUDIO_PCM_CMD_TIMESTAMP:
16101 {
16102 *((MS_U32 *)pData) = pPcmInfo->u32Timestamp;
16103 break;
16104 }
16105
16106 case AUDIO_PCM_CMD_WEIGHTING:
16107 {
16108 *((MS_U32 *)pData) = pPcmInfo->u32Weighting;
16109 break;
16110 }
16111
16112 case AUDIO_PCM_CMD_VOLUME:
16113 {
16114 *((MS_U32 *)pData) = pPcmInfo->u32Volume & (~0x80000000);
16115 break;
16116 }
16117
16118 case AUDIO_PCM_CMD_BUFFERLEVEL:
16119 {
16120 MS_U32 u32BufferLevel1 = 0;
16121 MS_U32 u32BufferLevel2 = 0;
16122 MS_U32 u32Timeout = 20;
16123
16124 while (u32Timeout > 0)
16125 {
16126 u32BufferLevel1 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
16127 u32BufferLevel2 = HAL_AUDIO_AbsReadReg(NewDMAwriter_DRAM_levelcnt) * BYTES_IN_MIU_LINE;
16128
16129 if (u32BufferLevel1 == u32BufferLevel2)
16130 {
16131 break;
16132 }
16133
16134 u32Timeout--;
16135
16136 #ifdef MSOS_TYPE_LINUX_KERNEL
16137 udelay(1);
16138 #else
16139 AUDIO_DELAY1US(1);
16140 #endif
16141 }
16142
16143 if (u32BufferLevel1 != u32BufferLevel2)
16144 {
16145 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! fail to get correct buffer level (%u, %u)\n", __FUNCTION__, u32BufferLevel1, u32BufferLevel2);
16146 }
16147
16148 pPcmInfo->u32BufferLevel = u32BufferLevel2;
16149 *((MS_U32 *)pData) = pPcmInfo->u32BufferLevel;
16150
16151 break;
16152 }
16153
16154 case AUDIO_PCM_CMD_MUTE:
16155 {
16156 *((MS_U32 *)pData) = ((pPcmInfo->u32Volume & 0x80000000) > 0) ? TRUE : FALSE;
16157 break;
16158 }
16159
16160 case AUDIO_PCM_CMD_BUFFERSIZE:
16161 {
16162 *((MS_U32 *)pData) = HW_DMA_WTR1_BUF_SIZE;
16163
16164 break;
16165 }
16166
16167 default:
16168 {
16169 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! unsupported command type(%u)!\n", __FUNCTION__, (unsigned int)u32Cmd);
16170 break;
16171 }
16172 }
16173
16174 return s32Ret;
16175 }
16176
HAL_AUDIO_PCM_HwDma_Writer1_Read(void * pBuf,MS_U32 u32Size)16177 MS_U32 HAL_AUDIO_PCM_HwDma_Writer1_Read(void *pBuf, MS_U32 u32Size)
16178 {
16179 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
16180 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
16181 MS_S8 *pBufTmp = NULL;
16182 MS_U32 u32BufferSize = 0;
16183 MS_U32 u32PcmLevel = 0;
16184 MS_U32 u32RequestSize = 0;
16185 MS_U32 u32RequestSizeTmp = 0;
16186 MS_U32 u32SizeToCopy = 0;
16187 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Write %u bytes to %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
16188
16189 if (pBuf == NULL)
16190 {
16191 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
16192 return 0;
16193 }
16194
16195 if (u32Size == 0)
16196 {
16197 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, (unsigned int)u32Size);
16198 return 0;
16199 }
16200
16201 if (pPcmInfo->u8ConnectFlag == FALSE)
16202 {
16203 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not opened yet!\n", __FUNCTION__);
16204 return 0;
16205 }
16206
16207 if (pPcmInfo->u8StartFlag == FALSE)
16208 {
16209 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Not started yet!\n", __FUNCTION__);
16210 return 0;
16211 }
16212
16213 pBufTmp = (MS_S8 *)pBuf;
16214
16215 u32BufferSize = (pPcmInfo->u32BufferDuration * pPcmInfo->u32SampleRate * pPcmInfo->u32Channel * 2) / 1000;
16216 HAL_AUDIO_PCM_HwDma_Writer1_Get(AUDIO_PCM_CMD_BUFFERLEVEL, &u32PcmLevel);
16217
16218 u32RequestSize = u32Size;
16219 u32RequestSizeTmp = u32RequestSize;
16220
16221 /* copy data from PCM buffer */
16222 if (u32PcmLevel >= u32RequestSize)
16223 {
16224 do {
16225 u32SizeToCopy = (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize) - pPCM->tPcmBufferInfo.pReadPtr;
16226 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
16227
16228 #ifdef MSOS_TYPE_LINUX_KERNEL
16229 memcpy_toio((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
16230 #else
16231 memcpy((void *)pBufTmp, (void *)pPCM->tPcmBufferInfo.pReadPtr, u32SizeToCopy);
16232 #endif
16233
16234 pBufTmp += u32SizeToCopy;
16235 pPCM->tPcmBufferInfo.pReadPtr += u32SizeToCopy;
16236 if (pPCM->tPcmBufferInfo.pReadPtr >= (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
16237 {
16238 if (pPCM->tPcmBufferInfo.pReadPtr > (pPCM->tPcmBufferInfo.pBuffer + u32BufferSize))
16239 {
16240 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
16241 }
16242 pPCM->tPcmBufferInfo.pReadPtr = pPCM->tPcmBufferInfo.pBuffer;
16243 }
16244
16245 u32RequestSizeTmp -= u32SizeToCopy;
16246 } while (u32RequestSizeTmp > 0);
16247
16248 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0010);
16249 HAL_AUR2_WriteMaskReg(NewDMAwriter_CPU_triggersize, 0xFFFF, u32RequestSize/BYTES_IN_MIU_LINE);
16250 HAL_AUR2_WriteMaskReg(NewDMAwriter_ctrl, 0x0010, 0x0000);
16251
16252 return u32Size;
16253 }
16254 return 0;
16255 }
16256
HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)16257 MS_S32 HAL_AUDIO_PCM_HwDma_Writer1_Flush(void)
16258 {
16259 AUDIO_PCM_t *pPCM = &Audio_Pcm_HwDma_Writer1;
16260 AUDIO_PCM_INFO_t *pPcmInfo = pPCM->pPcmInfo;
16261 MS_S32 s32Ret = 0;
16262 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Flush %s\n", __FUNCTION__, pPCM->u8Name);
16263
16264 if (pPcmInfo->u8StartFlag == FALSE)
16265 {
16266 HAL_AUDIO_PCM_HwDma_Writer1_Restart();
16267 HAL_AUDIO_PCM_HwDma_Writer1_Stop();
16268 }
16269
16270 return s32Ret;
16271 }
16272 #endif
16273
HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)16274 AUDIO_DSP_CODE_TYPE HAL_AUDIO_Convert_EnDVBdecSystemType_to_AudioDspCodeType(En_DVB_decSystemType enDecSystem)
16275 {
16276 AUDIO_DSP_CODE_TYPE dspCodeType = AU_DVB_STANDARD_INVALID;
16277
16278 switch (enDecSystem)
16279 {
16280 case MSAPI_AUD_ATV_BTSC:
16281 dspCodeType = AU_SIF_BTSC;
16282 break;
16283 case MSAPI_AUD_ATV_PAL:
16284 dspCodeType = AU_SIF_PALSUM;
16285 break;
16286 case MSAPI_AUD_DVB_MPEG:
16287 dspCodeType = AU_DVB_STANDARD_MPEG;
16288 break;
16289 case MSAPI_AUD_DVB_AC3:
16290 dspCodeType = AU_DVB_STANDARD_AC3;
16291 break;
16292 case MSAPI_AUD_DVB_AC3P:
16293 dspCodeType = AU_DVB_STANDARD_AC3P;
16294 break;
16295 case MSAPI_AUD_DVB_AAC:
16296 dspCodeType = AU_DVB_STANDARD_AAC;
16297 break;
16298 case MSAPI_AUD_DVB_MP3:
16299 dspCodeType = AU_DVB_STANDARD_MP3;
16300 break;
16301 case MSAPI_AUD_DVB_WMA:
16302 dspCodeType = AU_DVB_STANDARD_WMA;
16303 break;
16304 case MSAPI_AUD_DVB_RA8LBR:
16305 dspCodeType = AU_DVB_STANDARD_RA8LBR;
16306 break;
16307 case MSAPI_AUD_DVB_XPCM:
16308 dspCodeType = AU_DVB_STANDARD_XPCM;
16309 break;
16310 case MSAPI_AUD_DVB_DTS:
16311 dspCodeType = AU_DVB_STANDARD_DTS;
16312 break;
16313 case MSAPI_AUD_DVB_MS10_DDT:
16314 dspCodeType = AU_DVB_STANDARD_MS10_DDT;
16315 break;
16316 case MSAPI_AUD_DVB_MS10_DDC:
16317 dspCodeType = AU_DVB_STANDARD_MS10_DDC;
16318 break;
16319 case MSAPI_AUD_DVB_WMA_PRO:
16320 dspCodeType = AU_DVB_STANDARD_WMA_PRO;
16321 break;
16322 case MSAPI_AUD_DVB_FLAC:
16323 dspCodeType = AU_DVB_STANDARD_FLAC;
16324 break;
16325 case MSAPI_AUD_DVB_VORBIS:
16326 dspCodeType = AU_DVB_STANDARD_VORBIS;
16327 break;
16328 case MSAPI_AUD_DVB_DTSLBR:
16329 dspCodeType = AU_DVB_STANDARD_DTSLBR;
16330 break;
16331 case MSAPI_AUD_DVB_DRA:
16332 dspCodeType = AU_DVB_STANDARD_DRA;
16333 break;
16334 default:
16335 break;
16336 }
16337
16338 return dspCodeType;
16339 }
16340
HAL_AUDIO_ResetDspCodeType(void)16341 void HAL_AUDIO_ResetDspCodeType(void)
16342 {
16343 g_AudioVars2->g_DspCodeType = AU_DVB_STANDARD_INVALID;
16344 g_AudioVars2->g_Dsp2CodeType = AU_DVB_STANDARD_INVALID;
16345 g_AudioVars2->g_AdvSndEffDspCodeType = AU_DVB_STANDARD_INVALID;
16346 }
16347
HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)16348 MS_S32 HAL_AUDIO_CheckHashkeyDone(MS_U32 ip_auth)
16349 {
16350 MS_U32 Waittime = 0;
16351 MS_U32 ip_auth_temp = 0;
16352
16353 Waittime = MsOS_GetSystemTime();
16354
16355 while (1) {
16356 ip_auth_temp = HAL_DEC_R2_Get_SHM_INFO( R2_SHM_INFO_SECURITY_INFO, ADEC1);
16357
16358 if (ip_auth_temp == ip_auth) {
16359 return TRUE;
16360 }
16361 else {
16362 if (MsOS_Timer_DiffTimeFromNow(Waittime) > 1000) {
16363 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! Hashkey not match over 1s !\n", __FUNCTION__);
16364 return -A_EINVAL;
16365 }
16366 }
16367 }
16368 }
16369
HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)16370 MS_S32 HAL_AUDIO_InputSwitch(AUDIO_SWITCH_GROUP enGroup)
16371 {
16372 MS_U8 u8PcmRenderControl = 0; //0: decoder mode, 1: multi-channel mode, 2: stereo mode
16373
16374 HALAUDIO_CHECK_SHM_INIT;
16375
16376 switch (enGroup)
16377 {
16378 case E_AUDIO_GROUP_MAIN:
16379 {
16380 switch (g_AudioVars2->eAudioSource)
16381 {
16382 case E_AUDIO_INFO_DTV_IN:
16383 case E_AUDIO_INFO_MM_IN:
16384 case E_AUDIO_INFO_GAME_IN:
16385 {
16386 u8PcmRenderControl = 0; //decoder mode
16387 break;
16388 }
16389
16390 case E_AUDIO_INFO_ATV_IN:
16391 case E_AUDIO_INFO_HDMI_IN:
16392 case E_AUDIO_INFO_ADC_IN:
16393 case E_AUDIO_INFO_SPDIF_IN:
16394 case E_AUDIO_INFO_KTV_IN:
16395 case E_AUDIO_INFO_KTV_STB_IN:
16396 default:
16397 {
16398 u8PcmRenderControl = 2; //stereo mode
16399 break;
16400 }
16401 }
16402
16403 /* configure a default setting to R2's PCM Render accroding to current input source */
16404 printf("%s() enGroup:%x eAudioSource:%x u8PcmRenderControl << 1=%d\n", __FUNCTION__, enGroup,g_AudioVars2->eAudioSource,u8PcmRenderControl << 1);
16405 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_DAP_SEL, 0x06, (u8PcmRenderControl << 1));
16406
16407 break;
16408 }
16409
16410 default:
16411 {
16412 break;
16413 }
16414 }
16415
16416 return 0;
16417 }
16418
HAL_AUDIO_MP3_ENCODER1_Open(void)16419 MS_S32 HAL_AUDIO_MP3_ENCODER1_Open(void)
16420 {
16421 #if AUDIO_MP3_ENCODER1_SUPPORT
16422 MS_S32 s32Ret = 0;
16423
16424 /* enable MP3 Encoder1 */
16425 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x01, 0x01);
16426
16427 HAL_AUDIO_MP3_ENCODER1_Stop();
16428
16429 /* reset read pointer */
16430 g_u32Mp3Encoder1RptrOffset = 0;
16431 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
16432
16433 return s32Ret;
16434 #else
16435 return 0;
16436 #endif
16437 }
16438
HAL_AUDIO_MP3_ENCODER1_Close(void)16439 MS_S32 HAL_AUDIO_MP3_ENCODER1_Close(void)
16440 {
16441 #if AUDIO_MP3_ENCODER1_SUPPORT
16442 MS_S32 s32Ret = 0;
16443
16444 HAL_AUDIO_MP3_ENCODER1_Flush();
16445
16446 /* disable MP3 Encoder1 */
16447 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x01, 0x00);
16448
16449 return s32Ret;
16450 #else
16451 return 0;
16452 #endif
16453 }
16454
HAL_AUDIO_MP3_ENCODER1_Start(void)16455 MS_S32 HAL_AUDIO_MP3_ENCODER1_Start(void)
16456 {
16457 #if AUDIO_MP3_ENCODER1_SUPPORT
16458 MS_S32 s32Ret = 0;
16459
16460 /* start MP3 Encoder1 */
16461 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x02, 0x02);
16462
16463 return s32Ret;
16464 #else
16465 return 0;
16466 #endif
16467 }
16468
HAL_AUDIO_MP3_ENCODER1_Stop(void)16469 MS_S32 HAL_AUDIO_MP3_ENCODER1_Stop(void)
16470 {
16471 #if AUDIO_MP3_ENCODER1_SUPPORT
16472 MS_S32 s32Ret = 0;
16473
16474 /* stop MP3 Encoder1 */
16475 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x02, 0x00);
16476
16477 return s32Ret;
16478 #else
16479 return 0;
16480 #endif
16481 }
16482
HAL_AUDIO_MP3_ENCODER1_Ioctl(MS_U32 u32Cmd,void * pData)16483 MS_S32 HAL_AUDIO_MP3_ENCODER1_Ioctl(MS_U32 u32Cmd, void *pData)
16484 {
16485 #if AUDIO_MP3_ENCODER1_SUPPORT
16486 MS_U8 u8DeviceId = 0;
16487 MS_S32 s32Ret = 0;
16488
16489 if (pData == NULL)
16490 {
16491 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
16492 return -A_EFAULT;
16493 }
16494
16495 switch (u32Cmd)
16496 {
16497 case AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET:
16498 {
16499 HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_MP3_ENCODER_READ_PTR, u8DeviceId, *((MS_U32 *)pData), 0);
16500 break;
16501 }
16502
16503 case AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET:
16504 {
16505 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_WRITE_PTR, u8DeviceId);
16506 break;
16507 }
16508
16509 case AUDIO_ENCODER_IOCTL_GET_THRESHOLD:
16510 {
16511 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_THRESHOLD, u8DeviceId);
16512 break;
16513 }
16514
16515 case AUDIO_ENCODER_IOCTL_GET_FRAME_SIZE:
16516 {
16517 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_SIZE, u8DeviceId);
16518 break;
16519 }
16520
16521 case AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE:
16522 {
16523 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_AVAILABLE_SIZE, u8DeviceId);
16524 break;
16525 }
16526
16527 case AUDIO_ENCODER_IOCTL_GET_FRAME_COUNT:
16528 {
16529 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_COUNT, u8DeviceId);
16530 break;
16531 }
16532
16533 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_HIGH32BIT:
16534 {
16535 MS_U32 u32Data = 0;
16536
16537 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16538 u32Data = (u32Data & 0x80000000) >> 31;
16539 *((MS_U32 *)pData) = u32Data;
16540 break;
16541 }
16542
16543 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_LOW32BIT:
16544 {
16545 MS_U32 u32Data = 0;
16546
16547 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16548 u32Data = (u32Data << 1) & 0xFFFFFFFF;
16549 *((MS_U32 *)pData) = u32Data;
16550 break;
16551 }
16552
16553 default:
16554 {
16555 s32Ret = -A_EINVAL;
16556 break;
16557 }
16558 }
16559
16560 return s32Ret;
16561 #else
16562 return 0;
16563 #endif
16564 }
16565
HAL_AUDIO_MP3_ENCODER1_Read(void * pBuf,MS_U32 u32Size)16566 MS_U32 HAL_AUDIO_MP3_ENCODER1_Read(void *pBuf, MS_U32 u32Size)
16567 {
16568 #if AUDIO_MP3_ENCODER1_SUPPORT
16569 MS_S8 *pEncoderBuf = NULL;
16570 MS_S8 *pEncoderReadPtr = NULL;
16571 MS_S8 *pBufTmp = NULL;
16572 MS_U32 u32TargetBufferAddrPa = 0;
16573 MS_U32 u32BufferSize = 0;
16574 MS_U32 u32Mp3Level = 0;
16575 MS_U32 u32RequestSize = 0;
16576 MS_U32 u32RequestSizeTmp = 0;
16577 MS_U32 u32SizeToCopy = 0;
16578 MS_U32 u32Threshold = 0;
16579 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Read %u bytes from %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
16580
16581 if (pBuf == NULL)
16582 {
16583 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
16584 return 0;
16585 }
16586
16587 if (u32Size == 0)
16588 {
16589 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
16590 return 0;
16591 }
16592
16593 pBufTmp = (MS_S8 *)pBuf;
16594
16595 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + MP3_ENCODER1_BUF_ADDR;
16596 pEncoderBuf = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
16597 if (pEncoderBuf == NULL)
16598 {
16599 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pEncoderBuf should not be NULL!\n", __FUNCTION__);
16600 return 0;
16601 }
16602
16603 u32BufferSize = MP3_ENCODER1_BUF_SIZE;
16604 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE, &u32Mp3Level);
16605 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_THRESHOLD, &u32Threshold);
16606 if (u32Mp3Level >= (u32BufferSize - u32Threshold))
16607 {
16608 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer full!\n", __FUNCTION__);
16609
16610 u32Mp3Level = 0;
16611 HAL_AUDIO_MP3_ENCODER1_Stop();
16612 HAL_AUDIO_MP3_ENCODER1_Flush();
16613 HAL_AUDIO_MP3_ENCODER1_Start();
16614 }
16615 else if (u32Mp3Level == 0)
16616 {
16617 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16618 }
16619
16620 u32RequestSize = u32Size;
16621 u32RequestSizeTmp = u32RequestSize;
16622
16623 pEncoderReadPtr = pEncoderBuf + g_u32Mp3Encoder1RptrOffset;
16624
16625 //HALAUDIO_ERROR("[%u] %s: u32BufferSize %u, u32Threshold %u, u32Mp3Level %u, u32RequestSize %u\n", MsOS_GetSystemTime(), __FUNCTION__, u32BufferSize, u32Threshold, u32Mp3Level, u32RequestSize);
16626
16627 if (u32Mp3Level <= u32Threshold)
16628 {
16629 return 0;
16630 }
16631 u32Mp3Level -= u32Threshold;
16632
16633 /* copy data from PCM buffer */
16634 if (u32Mp3Level >= u32RequestSize)
16635 {
16636 do {
16637 u32SizeToCopy = (pEncoderBuf + u32BufferSize) - pEncoderReadPtr;
16638 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
16639
16640 /* read MIU */
16641 MsOS_ReadMemory();
16642
16643 #ifdef MSOS_TYPE_LINUX_KERNEL
16644 memcpy_toio((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16645 #else
16646 memcpy((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16647 #endif
16648 //HALAUDIO_ERROR("[%u] %s: g_u32Mp3Encoder1RptrOffset 0x%08X, SizeToCopy %u, ReadPtr 0x%08X, Buf 0x%08X, BufEnd 0x%08X\n", MsOS_GetSystemTime(), __FUNCTION__, g_u32Mp3Encoder1RptrOffset, u32SizeToCopy, pEncoderReadPtr, pEncoderBuf, (pEncoderBuf + u32BufferSize));
16649
16650 pBufTmp += u32SizeToCopy;
16651 pEncoderReadPtr += u32SizeToCopy;
16652 if (pEncoderReadPtr >= (pEncoderBuf + u32BufferSize))
16653 {
16654 if (pEncoderReadPtr > (pEncoderBuf + u32BufferSize))
16655 {
16656 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
16657 }
16658 pEncoderReadPtr = pEncoderBuf;
16659 }
16660
16661 u32RequestSizeTmp -= u32SizeToCopy;
16662 } while (u32RequestSizeTmp > 0);
16663
16664 /* flush MIU */
16665 MsOS_FlushMemory();
16666
16667 /* update read pointer to engine */
16668 g_u32Mp3Encoder1RptrOffset = pEncoderReadPtr - pEncoderBuf;
16669 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
16670
16671 return u32Size;
16672 }
16673
16674 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16675
16676 return 0;
16677 #else
16678 return 0;
16679 #endif
16680 }
16681
HAL_AUDIO_MP3_ENCODER1_Flush(void)16682 MS_S32 HAL_AUDIO_MP3_ENCODER1_Flush(void)
16683 {
16684 #if AUDIO_MP3_ENCODER1_SUPPORT
16685 MS_U32 u32WptrOffset = 0;
16686 MS_S32 s32Ret = 0;
16687
16688 /* set read pointer as write pointer to flush data in buffer */
16689 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET, &u32WptrOffset);
16690 g_u32Mp3Encoder1RptrOffset = u32WptrOffset;
16691 HAL_AUDIO_MP3_ENCODER1_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder1RptrOffset);
16692
16693 return s32Ret;
16694 #else
16695 return 0;
16696 #endif
16697 }
16698
HAL_AUDIO_MP3_ENCODER2_Open(void)16699 MS_S32 HAL_AUDIO_MP3_ENCODER2_Open(void)
16700 {
16701 #if AUDIO_MP3_ENCODER2_SUPPORT
16702 MS_S32 s32Ret = 0;
16703
16704 /* enable MP3 Encoder2 */
16705 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x04, 0x04);
16706
16707 HAL_AUDIO_MP3_ENCODER2_Stop();
16708
16709 /* reset read pointer */
16710 g_u32Mp3Encoder2RptrOffset = 0;
16711 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16712
16713 return s32Ret;
16714 #else
16715 return 0;
16716 #endif
16717 }
16718
HAL_AUDIO_MP3_ENCODER2_Close(void)16719 MS_S32 HAL_AUDIO_MP3_ENCODER2_Close(void)
16720 {
16721 #if AUDIO_MP3_ENCODER2_SUPPORT
16722 MS_S32 s32Ret = 0;
16723
16724 HAL_AUDIO_MP3_ENCODER2_Flush();
16725
16726 /* disable MP3 Encoder2 */
16727 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x04, 0x00);
16728
16729 return s32Ret;
16730 #else
16731 return 0;
16732 #endif
16733 }
16734
HAL_AUDIO_MP3_ENCODER2_Start(void)16735 MS_S32 HAL_AUDIO_MP3_ENCODER2_Start(void)
16736 {
16737 #if AUDIO_MP3_ENCODER2_SUPPORT
16738 MS_S32 s32Ret = 0;
16739
16740 /* start MP3 Encoder2 */
16741 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x08, 0x08);
16742
16743 return s32Ret;
16744 #else
16745 return 0;
16746 #endif
16747 }
16748
HAL_AUDIO_MP3_ENCODER2_Stop(void)16749 MS_S32 HAL_AUDIO_MP3_ENCODER2_Stop(void)
16750 {
16751 #if AUDIO_MP3_ENCODER2_SUPPORT
16752 MS_S32 s32Ret = 0;
16753
16754 /* stop MP3 Encoder2 */
16755 HAL_AUR2_WriteMaskByte(REG_SNDR2_MBOX_BYTE_TRANSCODE_SEL, 0x08, 0x00);
16756
16757 return s32Ret;
16758 #else
16759 return 0;
16760 #endif
16761 }
16762
HAL_AUDIO_MP3_ENCODER2_Ioctl(MS_U32 u32Cmd,void * pData)16763 MS_S32 HAL_AUDIO_MP3_ENCODER2_Ioctl(MS_U32 u32Cmd, void *pData)
16764 {
16765 #if AUDIO_MP3_ENCODER2_SUPPORT
16766 MS_U8 u8DeviceId = 1;
16767 MS_S32 s32Ret = 0;
16768
16769 if (pData == NULL)
16770 {
16771 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pData should not be NULL!\n", __FUNCTION__);
16772 return -A_EFAULT;
16773 }
16774
16775 switch (u32Cmd)
16776 {
16777 case AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET:
16778 {
16779 HAL_SND_R2_Set_SHM_PARAM(R2_SHM_PARAM_MP3_ENCODER_READ_PTR, u8DeviceId, *((MS_U32 *)pData), 0);
16780 break;
16781 }
16782
16783 case AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET:
16784 {
16785 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_WRITE_PTR, u8DeviceId);
16786 break;
16787 }
16788
16789 case AUDIO_ENCODER_IOCTL_GET_THRESHOLD:
16790 {
16791 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_THRESHOLD, u8DeviceId);
16792 break;
16793 }
16794
16795 case AUDIO_ENCODER_IOCTL_GET_FRAME_SIZE:
16796 {
16797 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_SIZE, u8DeviceId);
16798 break;
16799 }
16800
16801 case AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE:
16802 {
16803 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_AVAILABLE_SIZE, u8DeviceId);
16804 break;
16805 }
16806
16807 case AUDIO_ENCODER_IOCTL_GET_FRAME_COUNT:
16808 {
16809 *((MS_U32 *)pData) = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_FRAME_COUNT, u8DeviceId);
16810 break;
16811 }
16812
16813 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_HIGH32BIT:
16814 {
16815 MS_U32 u32Data = 0;
16816
16817 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16818 u32Data = (u32Data & 0x80000000) >> 31;
16819 *((MS_U32 *)pData) = u32Data;
16820 break;
16821 }
16822
16823 case AUDIO_ENCODER_IOCTL_GET_TIMESTAMP_LOW32BIT:
16824 {
16825 MS_U32 u32Data = 0;
16826
16827 u32Data = HAL_SND_R2_Get_SHM_INFO(R2_SHM_INFO_MP3_ENCODER_TIMESTAMP, u8DeviceId);
16828 u32Data = (u32Data << 1) & 0xFFFFFFFF;
16829 *((MS_U32 *)pData) = u32Data;
16830 break;
16831 }
16832
16833 default:
16834 {
16835 s32Ret = -A_EINVAL;
16836 break;
16837 }
16838 }
16839
16840 return s32Ret;
16841 #else
16842 return 0;
16843 #endif
16844 }
16845
HAL_AUDIO_MP3_ENCODER2_Read(void * pBuf,MS_U32 u32Size)16846 MS_U32 HAL_AUDIO_MP3_ENCODER2_Read(void *pBuf, MS_U32 u32Size)
16847 {
16848 #if AUDIO_MP3_ENCODER2_SUPPORT
16849 MS_S8 *pEncoderBuf = NULL;
16850 MS_S8 *pEncoderReadPtr = NULL;
16851 MS_S8 *pBufTmp = NULL;
16852 MS_U32 u32TargetBufferAddrPa = 0;
16853 MS_U32 u32BufferSize = 0;
16854 MS_U32 u32Mp3Level = 0;
16855 MS_U32 u32RequestSize = 0;
16856 MS_U32 u32RequestSizeTmp = 0;
16857 MS_U32 u32SizeToCopy = 0;
16858 MS_U32 u32Threshold = 0;
16859 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Read %u bytes from %s\n", __FUNCTION__, u32Size, pPCM->u8Name);
16860
16861 if (pBuf == NULL)
16862 {
16863 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pBuf should not be NULL!\n", __FUNCTION__);
16864 return 0;
16865 }
16866
16867 if (u32Size == 0)
16868 {
16869 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! u32Size(%u) is invalid!\n", __FUNCTION__, u32Size);
16870 return 0;
16871 }
16872
16873 pBufTmp = (MS_S8 *)pBuf;
16874
16875 u32TargetBufferAddrPa = HAL_AUDIO_GetDspMadBaseAddr(DSP_SE) + MP3_ENCODER2_BUF_ADDR;
16876 pEncoderBuf = (MS_S8 *)MS_PA2KSEG1(u32TargetBufferAddrPa);
16877 if (pEncoderBuf == NULL)
16878 {
16879 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Error! pEncoderBuf should not be NULL!\n", __FUNCTION__);
16880 return 0;
16881 }
16882
16883 u32BufferSize = MP3_ENCODER2_BUF_SIZE;
16884 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_AVAILABLE_SIZE, &u32Mp3Level);
16885 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_THRESHOLD, &u32Threshold);
16886 if (u32Mp3Level >= (u32BufferSize - u32Threshold))
16887 {
16888 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer full!\n", __FUNCTION__);
16889
16890 u32Mp3Level = 0;
16891 HAL_AUDIO_MP3_ENCODER2_Stop();
16892 HAL_AUDIO_MP3_ENCODER2_Flush();
16893 HAL_AUDIO_MP3_ENCODER2_Start();
16894 }
16895 else if (u32Mp3Level == 0)
16896 {
16897 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16898 }
16899
16900 u32RequestSize = u32Size;
16901 u32RequestSizeTmp = u32RequestSize;
16902
16903 pEncoderReadPtr = pEncoderBuf + g_u32Mp3Encoder2RptrOffset;
16904
16905 //HALAUDIO_ERROR("[%u] %s: u32BufferSize %u, u32Threshold %u, u32Mp3Level %u, u32RequestSize %u\n", MsOS_GetSystemTime(), __FUNCTION__, u32BufferSize, u32Threshold, u32Mp3Level, u32RequestSize);
16906
16907 if (u32Mp3Level <= u32Threshold)
16908 {
16909 return 0;
16910 }
16911 u32Mp3Level -= u32Threshold;
16912
16913 /* copy data from PCM buffer */
16914 if (u32Mp3Level >= u32RequestSize)
16915 {
16916 do {
16917 u32SizeToCopy = (pEncoderBuf + u32BufferSize) - pEncoderReadPtr;
16918 u32SizeToCopy = (u32SizeToCopy > u32RequestSizeTmp) ? u32RequestSizeTmp : u32SizeToCopy;
16919
16920 /* read MIU */
16921 MsOS_ReadMemory();
16922
16923 #ifdef MSOS_TYPE_LINUX_KERNEL
16924 memcpy_toio((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16925 #else
16926 memcpy((void *)pBufTmp, (void *)pEncoderReadPtr, u32SizeToCopy);
16927 #endif
16928 //HALAUDIO_ERROR("[%u] %s: g_u32Mp3Encoder2RptrOffset 0x%08X, SizeToCopy %u, ReadPtr 0x%08X, Buf 0x%08X, BufEnd 0x%08X\n", MsOS_GetSystemTime(), __FUNCTION__, g_u32Mp3Encoder2RptrOffset, u32SizeToCopy, pEncoderReadPtr, pEncoderBuf, (pEncoderBuf + u32BufferSize));
16929
16930 pBufTmp += u32SizeToCopy;
16931 pEncoderReadPtr += u32SizeToCopy;
16932 if (pEncoderReadPtr >= (pEncoderBuf + u32BufferSize))
16933 {
16934 if (pEncoderReadPtr > (pEncoderBuf + u32BufferSize))
16935 {
16936 AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! it's an abnormal copy!\n", __FUNCTION__);
16937 }
16938 pEncoderReadPtr = pEncoderBuf;
16939 }
16940
16941 u32RequestSizeTmp -= u32SizeToCopy;
16942 } while (u32RequestSizeTmp > 0);
16943
16944 /* flush MIU */
16945 MsOS_FlushMemory();
16946
16947 /* update read pointer to engine */
16948 g_u32Mp3Encoder2RptrOffset = pEncoderReadPtr - pEncoderBuf;
16949 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16950
16951 return u32Size;
16952 }
16953
16954 //AUDIO_PRINT(AUDIO_DEBUG_LEVEL_ERROR, "%s: Warning! MP3 buffer empty!\n", __FUNCTION__);
16955
16956 return 0;
16957 #else
16958 return 0;
16959 #endif
16960 }
16961
HAL_AUDIO_MP3_ENCODER2_Flush(void)16962 MS_S32 HAL_AUDIO_MP3_ENCODER2_Flush(void)
16963 {
16964 #if AUDIO_MP3_ENCODER2_SUPPORT
16965 MS_U32 u32WptrOffset = 0;
16966 MS_S32 s32Ret = 0;
16967
16968 /* set read pointer as write pointer to flush data in buffer */
16969 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_GET_WRITE_PTR_OFFSET, &u32WptrOffset);
16970 g_u32Mp3Encoder2RptrOffset = u32WptrOffset;
16971 HAL_AUDIO_MP3_ENCODER2_Ioctl(AUDIO_ENCODER_IOCTL_SET_READ_PTR_OFFSET, &g_u32Mp3Encoder2RptrOffset);
16972
16973 return s32Ret;
16974 #else
16975 return 0;
16976 #endif
16977 }