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 //-------------------------------------------------------------------------------------------------
97 // Include Files
98 //-------------------------------------------------------------------------------------------------
99 // Common Definition
100 #include "MsCommon.h"
101 #include "MsIRQ.h"
102 #include "MsOS.h"
103 #include "regCHIP.h"
104 #include "drvAUDIO_if.h"
105 #include "drvAUDIO.h"
106 #include "halAUDIO.h"
107
108 // Internal Definition
109 #include "halSOUND.h"
110 #include "regAUDIO.h"
111 #include "halMAD2.h"
112
113 #include "audio_mbox2.h"
114 #include "audio_comm2.h"
115
116 #if (defined ANDROID)
117
118 #include <sys/mman.h>
119 #include <cutils/ashmem.h>
120 #include <cutils/log.h>
121
122 #ifndef LOGI // android 4.1 rename LOGx to ALOGx
123 #define LOGI ALOGI
124 #endif
125
126 #ifndef LOGE // android 4.1 rename LOGx to ALOGx
127 #define LOGE ALOGE
128 #endif
129
130 #if(OMX_AUDIO_DEBUG)
131 #define HALSOUND_PRINT(fmt, args...) LOGI("<<android>> " fmt, ## args)
132 #else
133 #define HALSOUND_PRINT(fmt, args...)
134 #endif
135
136 #define HALSOUND_ERROR(fmt, args...) LOGE("<<android>> " fmt, ## args)
137
138 #else
139 #ifdef CONFIG_MBOOT //mboot Speed up
140 #define HALSOUND_PRINT(fmt, args...)
141 #define HALSOUND_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
142 #else
143 #define HALSOUND_PRINT(fmt, args...) printf("[[utopia]] " fmt, ## args)
144 #define HALSOUND_ERROR(fmt, args...) printf("[[utopia]] " fmt, ## args)
145 #endif
146 #endif
147
148
149 //-------------------------------------------------------------------------------------------------
150 // Driver Compiler Options
151 //-------------------------------------------------------------------------------------------------
152 #define DBG_SOUND(msg) //msg
153 #define MAX_PEQ_BAND 8
154 //-------------------------------------------------------------------------------------------------
155 // Local Defines
156 //-------------------------------------------------------------------------------------------------
157 #ifndef UNUSED
158 #define UNUSED(x) ((x)=(x))
159 #endif
160 //-------------------------------------------------------------------------------------------------
161 // Local Structures
162 //-------------------------------------------------------------------------------------------------
163
164
165 //-------------------------------------------------------------------------------------------------
166 // Global Variables
167 //-------------------------------------------------------------------------------------------------
168 extern MS_U16 g_BalanceMask;
169 extern AUDIO_SHARED_VARS2 * g_AudioVars2;
170 //-------------------------------------------------------------------------------------------------
171 // Local Variables
172 //-------------------------------------------------------------------------------------------------
173 static MS_U32 peq_band_enable = 0xFFFFFFFF;
174 static MS_U32 peq_band_precision = 0x00000000;
175
176 //-------------------------------------------------------------------------------------------------
177 // Debug Functions
178 //-------------------------------------------------------------------------------------------------
179
180
181 //-------------------------------------------------------------------------------------------------
182 // Local Functions
183 //-------------------------------------------------------------------------------------------------
184
185
186 //-------------------------------------------------------------------------------------------------
187 // Global Functions
188 //-------------------------------------------------------------------------------------------------
189
190 ////////////////////////////////////////////////////////////////////////////////
191 /// @brief \b Function \b Name: HAL_SOUND_Init() @@VVV
192 /// @brief \b Function \b Description: This routine is the initialization for Audio sound effect module.
193 /// @param <IN> \b InitTbl : Sound effect initial table
194 /// @param <OUT> \b NONE :
195 /// @param <RET> \b NONE :
196 /// @param <GLOBAL> \b NONE :
197 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_Init(void)198 void HAL_SOUND_Init(void)
199 {
200 // Toggle to initialize DAC DATA SRAM.
201 HAL_AUDIO_SeWriteMaskByte(0x2B40,0x02,0x02);
202 AUDIO_DELAY1MS(1);
203 HAL_AUDIO_SeWriteMaskByte(0x2B40,0x02,0x00);
204
205 //reset DSP
206 HAL_AUDIO_WriteByte( REG_SE_IDMA_CTRL0, 0x82);
207 AUDIO_DELAY1MS(2);
208 HAL_AUDIO_WriteByte( REG_SE_IDMA_CTRL0, 0x83);
209 }
210
211 ////////////////////////////////////////////////////////////////////////////////
212 /// @brief \b Function \b Name: HAL_SOUND_Init2
213 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_Init2(void)214 void HAL_SOUND_Init2(void)
215 {
216
217 HAL_SOUND_Init();
218 HAL_AUDIO_SeSystemLoadCode(); // Do nothing in single DSP chip
219 }
220
221 ////////////////////////////////////////////////////////////////////////////////
222 /// @brief \b Function \b Name: HAL_SOUND_SetMute() @@VVV
223 /// @brief \b Function \b Description: This routine is used to set audio u8Path S/W mute.
224 /// @param <IN> \b u8Path : for audio u8Path0 ~ u8Path6
225 /// @param <IN> \b bEnable : TRUE --Mute
226 /// FALSE--Unmute
227 /// @param <OUT> \b NONE :
228 /// @param <RET> \b NONE :
229 /// @param <GLOBAL> \b NONE :
230 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetMute(MS_U8 u8Path,MS_BOOL bEnable)231 void HAL_SOUND_SetMute(MS_U8 u8Path, MS_BOOL bEnable)
232 {
233 DBG_SOUND(printf("HAL_SOUND_SetMute = %x\n", (MS_U8)bEnable ));
234
235 switch(u8Path)
236 {
237 case AUDIO_T3_PATH_AUOUT0:
238 if(bEnable) // Mute
239 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT0_VOLUME, 0x80, 0x80);
240 else // UnMute
241 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT0_VOLUME, 0x80, 0x00);
242 break;
243
244 case AUDIO_T3_PATH_AUOUT1:
245 if(bEnable)
246 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT1_VOLUME, 0x80, 0x80 );
247 else
248 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT1_VOLUME, 0x80, 0x00 );
249 break;
250
251 case AUDIO_T3_PATH_AUOUT2:
252 if(bEnable)
253 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT2_VOLUME, 0x80, 0x80);
254 else
255 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT2_VOLUME, 0x80, 0x00);
256 break;
257
258 case AUDIO_T3_PATH_AUOUT3:
259 if(bEnable)
260 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT3_VOLUME, 0x80, 0x80);
261 else
262 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT3_VOLUME, 0x80, 0x00);
263 break;
264
265 case AUDIO_T3_PATH_I2S:
266 if(bEnable)
267 HAL_AUDIO_WriteMaskByte(REG_SOUND_I2S_VOLUME, 0x80, 0x80);
268 else
269 HAL_AUDIO_WriteMaskByte(REG_SOUND_I2S_VOLUME, 0x80, 0x00);
270 break;
271
272 case AUDIO_T3_PATH_SPDIF:
273 _HAL_AUDIO_SPDIF_SetMute(bEnable);
274 break;
275
276 case AUDIO_T3_PATH_MIXER_MAIN:
277 {
278 MS_U32 u32Value;
279
280 /* TODO
281 * It's a patch here
282 * also control multi channel volume
283 */
284 u32Value = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL);
285
286 if (bEnable)
287 {
288 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH5_MIX_VOL_INT, 0x80, 0x80);
289
290 u32Value = u32Value | 0x008000;
291 }
292 else
293 {
294 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH5_MIX_VOL_INT, 0x80, 0x00);
295
296 u32Value = u32Value & 0xFF7FFF;
297 }
298
299 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL, u32Value);
300
301 break;
302 }
303
304 case AUDIO_T3_PATH_MIXER_SECONDARY:
305 if(bEnable)
306 {
307 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH6_MIX_VOL_INT, 0x80, 0x80);
308 }
309 else
310 {
311 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH6_MIX_VOL_INT, 0x80, 0x00);
312 }
313 break;
314
315 case AUDIO_T3_PATH_MIXER_DMA_IN:
316 if(bEnable)
317 {
318 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH8_MIX_VOL_INT, 0x80, 0x80);
319 }
320 else
321 {
322 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH8_MIX_VOL_INT, 0x80, 0x00);
323 }
324 break;
325
326 case AUDIO_T3_PATH_PCM_CAPTURE1:
327 {
328 MS_U32 u32Value;
329
330 u32Value = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_pcmCapture_volume);
331
332 if (bEnable)
333 {
334 u32Value = u32Value | 0x008000;
335 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture_volume, u32Value);
336 }
337 else
338 {
339 u32Value = u32Value & 0xFF7FFF;
340 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture_volume, u32Value);
341 }
342
343 break;
344 }
345
346 case AUDIO_T3_PATH_PCM_CAPTURE2:
347 {
348 MS_U32 u32Value;
349
350 u32Value = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_pcmCapture2_volume);
351
352 if (bEnable)
353 {
354 u32Value = u32Value | 0x008000;
355 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture2_volume, u32Value);
356 }
357 else
358 {
359 u32Value = u32Value & 0xFF7FFF;
360 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture2_volume, u32Value);
361 }
362
363 break;
364 }
365
366 case AUDIO_T3_PATH_HDMI:
367 if(bEnable)
368 {
369 //HDMI Tx mute bit, also control by main channel
370 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOLUME, 0x80, 0x80);
371 _HAL_AUDIO_HDMI_Tx_SetMute(TRUE);
372 }
373 else
374 {
375 //HDMI Tx mute bit, also control by main channel
376 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOLUME, 0x80, 0x00);
377 _HAL_AUDIO_HDMI_Tx_SetMute(FALSE);
378 }
379 break;
380
381 case AUDIO_T3_PATH_MIXER_MCH_IN: //Multi-Ch 1~4
382 {
383 MS_U32 u32Value;
384
385 u32Value = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL);
386
387 if (bEnable)
388 {
389 u32Value = u32Value | 0x008000;
390 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL, u32Value);
391 }
392 else
393 {
394 u32Value = u32Value & 0xFF7FFF;
395 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL, u32Value);
396 }
397
398 break;
399 }
400
401 default:
402 break;
403 }
404 }
405
406 ////////////////////////////////////////////////////////////////////////////////
407 /// @brief \b Function \b Name: HAL_SOUND_AbsoluteVolume() @@VVV
408 /// @brief \b Function \b Description: This routine is used to set the absolute volume of audio u8Path.
409 /// @param <IN> \b u8Path : for audio CH1~CH6
410 /// @param <IN> \b u8u8Vol1 : MSB 7-bit register u8Value of 10-bit volume
411 /// range from 0x00 to 0x7E , gain: +12db to -114db (-1 db per step)
412 /// @param <IN> \b u8u8Vol2 : LSB 3-bit register u8Value of 10-bit volume
413 /// range from 0x00 to 0x07 , gain: -0db to -0.875db (-0.125 db per step)
414 /// @param <OUT> \b NONE :
415 /// @param <RET> \b NONE :
416 /// @param <GLOBAL> \b NONE :
417 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_AbsoluteVolume(MS_U8 u8Path,MS_U8 u8u8Vol1,MS_U8 u8u8Vol2)418 void HAL_SOUND_AbsoluteVolume(MS_U8 u8Path, MS_U8 u8u8Vol1, MS_U8 u8u8Vol2)
419 {
420 switch(u8Path)
421 {
422 case AUDIO_T3_PATH_AUOUT0:
423 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT0_VOLUME, 0x7F, u8u8Vol1);
424 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT0_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
425 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x01, 0x01); // bEnable DSP CH1 sound effect
426 break;
427
428 case AUDIO_T3_PATH_AUOUT1:
429 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT1_VOLUME, 0x7F, u8u8Vol1);
430 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT1_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
431 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x02, 0x02); // bEnable DSP CH2 sound effect
432 break;
433
434 case AUDIO_T3_PATH_AUOUT2:
435 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT2_VOLUME, 0x7F, u8u8Vol1);
436 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT2_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
437 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x04, 0x04); // bEnable DSP CH3 sound effect
438 break;
439 case AUDIO_T3_PATH_AUOUT3:
440 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT3_VOLUME, 0x7F, u8u8Vol1);
441 HAL_AUDIO_WriteMaskByte(REG_SOUND_AUOUT3_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
442 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x08, 0x08); // bEnable DSP CH4 sound effect
443 break;
444
445 case AUDIO_T3_PATH_I2S:
446 HAL_AUDIO_WriteMaskByte(REG_SOUND_I2S_VOLUME, 0x7F, u8u8Vol1);
447 HAL_AUDIO_WriteMaskByte(REG_SOUND_I2S_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
448 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x10, 0x10); // bEnable DSP CH5 sound effect
449 break;
450
451 case AUDIO_T3_PATH_SPDIF:
452 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOLUME, 0x7F, u8u8Vol1);
453 HAL_AUDIO_WriteMaskByte(REG_SOUND_SPDIF_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
454 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN, 0x20, 0x20); // bEnable DSP CH6 sound effect
455
456 break;
457
458 case AUDIO_T3_PATH_HDMI:
459 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOLUME, 0x7F, u8u8Vol1);
460 HAL_AUDIO_WriteMaskByte(REG_SOUND_HDMI_TX_VOL_FRAC, 0xE0, (u8u8Vol2<<5));
461 HAL_AUDIO_WriteMaskByte(M2S_MBOX_VOLUME_EN+1, 0x04, 0x04); // bEnable AUDIO_T3_PATH_HDMI
462 break;
463
464 case AUDIO_T3_PATH_MIXER_MAIN: //CH5
465 {
466 MS_U32 u32Value;
467 MS_U32 u32Muteflag;
468
469 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH5_MIX_VOL_INT, 0x7F, u8u8Vol1);
470 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH5_MIX_VOL_FRC, 0xE0, (u8u8Vol2<<5));
471
472 /* TODO
473 * It's a patch here
474 * also control multi channel volume
475 */
476 u32Muteflag = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL);
477
478 u8u8Vol1 = u8u8Vol1 & 0x7F;
479 u8u8Vol2 = (u8u8Vol2<<5) & 0xE0;
480 u32Value = ((MS_U32)u8u8Vol1)<<8;
481 u32Value = u32Value + (MS_U32)u8u8Vol2;
482 u32Value = u32Value | (u32Muteflag & 0x008000);
483 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL, u32Value);
484
485 break;
486 }
487
488 case AUDIO_T3_PATH_MIXER_SECONDARY: //CH6
489 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH6_MIX_VOL_INT, 0x7F, u8u8Vol1);
490 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH6_MIX_VOL_FRC, 0xE0, (u8u8Vol2<<5));
491 break;
492
493 case AUDIO_T3_PATH_MIXER_DMA_IN: //CH8
494 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH8_MIX_VOL_INT, 0x7F, u8u8Vol1);
495 HAL_AUDIO_WriteMaskByte(REG_SOUND_CH8_MIX_VOL_FRC, 0xE0, (u8u8Vol2<<5));
496 break;
497
498 case AUDIO_T3_PATH_PCM_CAPTURE1:
499 {
500 MS_U32 u32Value;
501 MS_U32 u32Muteflag;
502 u32Muteflag = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_pcmCapture_volume);
503
504 u8u8Vol1 = u8u8Vol1 & 0x7F;
505 u8u8Vol2 = (u8u8Vol2<<5) & 0xE0;
506 u32Value = ((MS_U32)u8u8Vol1)<<8;
507 u32Value = u32Value + (MS_U32)u8u8Vol2;
508 u32Value = u32Value | (u32Muteflag & 0x008000);
509 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture_volume, u32Value);
510
511 break;
512 }
513
514 case AUDIO_T3_PATH_PCM_CAPTURE2:
515 {
516 MS_U32 u32Value;
517 MS_U32 u32Muteflag;
518 u32Muteflag = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_pcmCapture2_volume);
519
520 u8u8Vol1 = u8u8Vol1 & 0x7F;
521 u8u8Vol2 = (u8u8Vol2<<5) & 0xE0;
522 u32Value = ((MS_U32)u8u8Vol1)<<8;
523 u32Value = u32Value + (MS_U32)u8u8Vol2;
524 u32Value = u32Value | (u32Muteflag & 0x008000);
525 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_pcmCapture2_volume, u32Value);
526
527 break;
528 }
529
530 case AUDIO_T3_PATH_MIXER_MCH_IN: //Multi-Ch 1~4
531 {
532 MS_U32 u32Value;
533 MS_U32 u32Muteflag;
534 u32Muteflag = HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL);
535
536 u8u8Vol1 = u8u8Vol1 & 0x7F;
537 u8u8Vol2 = (u8u8Vol2<<5) & 0xE0;
538 u32Value = ((MS_U32)u8u8Vol1)<<8;
539 u32Value = u32Value + (MS_U32)u8u8Vol2;
540 u32Value = u32Value | (u32Muteflag & 0x008000);
541 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_Multi_Channel_VOL, u32Value);
542
543 break;
544 }
545
546 default:
547 break;
548 }
549
550 }
551
552 ////////////////////////////////////////////////////////////////////////////////
553 /// @brief \b Function \b Name: HAL_SOUND_SetPreScale() @@VVV
554 /// @brief \b Function \b Description: This routine is used to set the u8Prescale of audio u8Path.
555 /// @param <IN> \b u8Path : for audio u8Path0 ~ u8Path5
556 /// @param <IN> \b u8Prescale : range from 0x01 to 0xFF , gain: -13.75db to +18db (0.125 db per step)
557 /// 0x00: disable pre-scale
558 /// 0x6F: gain = 0db
559 /// 0xFF: gain = +18db
560 /// @param <OUT> \b NONE :
561 /// @param <RET> \b NONE :
562 /// @param <GLOBAL> \b NONE :
563 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetPreScale(MS_U8 u8Path,MS_U8 u8Prescale)564 void HAL_SOUND_SetPreScale(MS_U8 u8Path, MS_U8 u8Prescale)
565 {
566 switch(u8Path)
567 {
568 case AUDIO_PATH_MAIN:
569 HAL_AUDIO_WriteByte(REG_SOUND_MAIN_PERSCALE, u8Prescale);
570 break;
571
572 default:
573 HAL_AUDIO_WriteByte(REG_SOUND_MAIN_PERSCALE, u8Prescale);
574 break;
575 }
576 }
577
578 ////////////////////////////////////////////////////////////////////////////////
579 /// @brief \b Function \b Name: HAL_SOUND_GetPreScale()
580 /// @brief \b Function \b Description: This routine is used to set the u8Prescale of audio u8Path.
581 /// @param <IN> \b u8Path : for audio u8Path0 ~ u8Path5
582 /// @param <IN> \b u8Prescale : range from 0x01 to 0xFF , gain: -13.75db to +18db (0.125 db per step)
583 /// 0x00: disable pre-scale
584 /// 0x6F: gain = 0db
585 /// 0xFF: gain = +18db
586 /// @param <OUT> \b NONE :
587 /// @param <RET> \b NONE :
588 /// @param <GLOBAL> \b NONE :
589 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetPreScale(MS_U8 u8Path)590 MS_U16 HAL_SOUND_GetPreScale(MS_U8 u8Path)
591 {
592 MS_U16 tmp=0;
593 switch ( u8Path )
594 {
595 case AUDIO_PATH_MAIN:
596 tmp = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_PERSCALE);
597 break;
598
599 default:
600 tmp = HAL_AUDIO_ReadByte(REG_SOUND_MAIN_PERSCALE);
601 break;
602 }
603 return tmp;
604 }
605
606 ////////////////////////////////////////////////////////////////////////////////
607 /// @brief \b Function \b Name: HAL_SOUND_EnableBalance() @@VVV
608 /// @brief \b Function \b Description: This routine is used to bEnable/disable Balance featue.
609 /// @param <IN> \b u8Enable : Balance Enable bits
610 /// @param <OUT> \b NONE :
611 /// @param <RET> \b NONE :
612 /// @param <GLOBAL> \b NONE :
613 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableBalance(MS_U8 u8Enable)614 void HAL_SOUND_EnableBalance(MS_U8 u8Enable)
615 {
616 HAL_AUDIO_WriteMaskByte(M2S_MBOX_BALANCE_EN+1, 0x80, (u8Enable<<7)); // Balance enable flag
617
618 if(u8Enable)
619 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0xFFFF); // Balance enable
620 else
621 HAL_AUDIO_WriteMaskReg(M2S_MBOX_BALANCE_EN, g_BalanceMask, 0x0000); // Balance disable
622 }
623
624 const MS_U8 BalanceTab[]=
625 {
626 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09, /// 0 ~ 9
627 0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13, /// 10 ~ 19
628 0x14,0x15,0x16,0x17,0x18,0x1A,0x1B,0x1C,0x1F,0x20, /// 20 ~ 29
629 0x22,0x23,0x25,0x27,0x29,0x2B,0x2E,0x30,0x33,0x36, /// 30 ~ 39
630 0x38,0x3D,0x41,0x46,0x4B,0x51,0x59,0x66,0x72,0x8B, /// 40 ~ 49
631 0xFF /// 50
632 };
633
634 ////////////////////////////////////////////////////////////////////////////////
635 /// @brief \b Function \b Name: HAL_SOUND_SetBalance_L() @@VVV
636 /// @brief \b Function \b Description: This routine is used to set absolute balance u8Value.
637 /// @param <IN> \b u8Balance : balance register u8Value
638 /// @param <OUT> \b NONE :
639 /// @param <RET> \b NONE :
640 /// @param <GLOBAL> \b NONE :
641 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetBalance(MS_U8 u8Balance)642 void HAL_SOUND_SetBalance(MS_U8 u8Balance)
643 {
644 MS_U8 value_l = 0, value_r = 0;
645
646 //printf("apiAud>> u8Balance = %02bx\n", u8Balance);
647 if(u8Balance==50)
648 {
649 value_l = 0x00;
650 value_r = 0x00;
651 }
652 else if(u8Balance<50)
653 {
654 value_l = 0x00;
655 value_r = BalanceTab[(50-u8Balance)];
656 }
657 else if(u8Balance>50)
658 {
659 value_l = BalanceTab[(u8Balance-50)];
660 value_r = 0x00;
661 }
662 //AUD_DEBUG(printf("\napiAud>> Balance UI:0x%bx L:0x%bx R:0x%bx",u8Balance,value_l,value_r));
663 HAL_SOUND_SetBalance_L(value_l );
664 HAL_SOUND_SetBalance_R(value_r );
665 }
666
667
668 ////////////////////////////////////////////////////////////////////////////////
669 /// @brief \b Function \b Name: HAL_SOUND_SetBalance_L() @@VVV
670 /// @brief \b Function \b Description: This routine is used to set absolute balance u8Value of main u8Path L-channel.
671 /// @param <IN> \b u8Balance_L : balance register u8Value
672 /// @param <OUT> \b NONE :
673 /// @param <RET> \b NONE :
674 /// @param <GLOBAL> \b NONE :
675 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetBalance_L(MS_U8 u8Balance_L)676 void HAL_SOUND_SetBalance_L(MS_U8 u8Balance_L)
677 {
678 HAL_AUDIO_WriteByte(REG_SOUND_BALANCEL, u8Balance_L);
679 }
680
681 ////////////////////////////////////////////////////////////////////////////////
682 /// @brief \b Function \b Name: HAL_SOUND_GetBalance_L()
683 /// @brief \b Function \b Description: This routine is used to set absolute balance u8Value of main u8Path L-channel.
684 /// @param <IN> \b u8Balance_L : balance register u8Value
685 /// @param <OUT> \b NONE :
686 /// @param <RET> \b NONE :
687 /// @param <GLOBAL> \b NONE :
688 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetBalance_L(void)689 MS_U16 HAL_SOUND_GetBalance_L(void)
690 {
691 return(HAL_AUDIO_ReadByte(REG_SOUND_BALANCEL));
692 }
693
694
695 ////////////////////////////////////////////////////////////////////////////////
696 /// @brief \b Function \b Name: HAL_SOUND_SetBalance_R() @@VVV
697 /// @brief \b Function \b Description: This routine is used to set absolute balance u8Value of main u8Path R-channel.
698 /// @param <IN> \b u8Balance_R : balance register u8Value
699 /// @param <OUT> \b NONE :
700 /// @param <RET> \b NONE :
701 /// @param <GLOBAL> \b NONE :
702 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetBalance_R(MS_U8 u8Balance_R)703 void HAL_SOUND_SetBalance_R(MS_U8 u8Balance_R)
704 {
705 HAL_AUDIO_WriteByte(REG_SOUND_BALANCER, u8Balance_R);
706 }
707
708 ////////////////////////////////////////////////////////////////////////////////
709 /// @brief \b Function \b Name: HAL_SOUND_GetBalance_R()
710 /// @brief \b Function \b Description: This routine is used to set absolute balance u8Value of main u8Path L-channel.
711 /// @param <IN> \b u8Balance_L : balance register u8Value
712 /// @param <OUT> \b NONE :
713 /// @param <RET> \b NONE :
714 /// @param <GLOBAL> \b NONE :
715 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetBalance_R(void)716 MS_U16 HAL_SOUND_GetBalance_R(void)
717 {
718 return(HAL_AUDIO_ReadByte(REG_SOUND_BALANCER));
719 }
720
721 ////////////////////////////////////////////////////////////////////////////////
722 /// @brief \b Function \b Name: HAL_SOUND_SetDynamicBass()
723 /// @brief \b Function \b Description: This routine is used to set the DynamicBass u8Level of main u8Path .
724 /// @param <IN> \b u8Level :
725 /// @param <OUT> \b NONE :
726 /// @param <RET> \b NONE :
727 /// @param <GLOBAL> \b NONE :
728 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetDynamicBass(MS_U8 u8Level)729 void HAL_SOUND_SetDynamicBass(MS_U8 u8Level)
730 {
731 if (u8Level > 0x0C)
732 u8Level = 0x0C;
733
734 HAL_AUDIO_WriteMaskByte(REG_SOUND_EQ_BASE, 0xF0, u8Level<<4);
735 if(u8Level == 0)
736 {
737 HAL_AUDIO_WriteMaskByte(REG_SOUND_MAIN_SNDEFFECT, 0x20, 0x00);
738 }
739 else
740 {
741 HAL_AUDIO_WriteMaskByte(REG_SOUND_MAIN_SNDEFFECT, 0x20, 0x20);
742 }
743 }
744
745 ////////////////////////////////////////////////////////////////////////////////
746 /// @brief \b Function \b Name: HAL_SOUND_SetBass() @@VVV
747 /// @brief \b Function \b Description: This routine is used to set the Bass u8Level of main u8Path .
748 /// @param <IN> \b u8Level : Bass u8Level (0~100) mapping to -16~+15dB
749 /// @param <OUT> \b NONE :
750 /// @param <RET> \b NONE :
751 /// @param <GLOBAL> \b NONE :
752 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetBass(MS_U8 u8Level)753 void HAL_SOUND_SetBass(MS_U8 u8Level)
754 {
755 int u8Value;
756
757 if(u8Level==100)
758 {
759 u8Value = 0x30;
760 }
761 else
762 {
763 u8Value = ((int)u8Level-50)*48/50; //16/50;
764 }
765
766 DBG_SOUND(printf("Bass:%d",u8Level));
767 DBG_SOUND(printf("==>%x\r\n",u8Value));
768
769 HAL_AUDIO_WriteByte(REG_SOUND_BASS, (MS_U8)u8Value);
770 }
771
772 ////////////////////////////////////////////////////////////////////////////////
773 /// @brief \b Function \b Name: HAL_SOUND_GetBass()
774 /// @brief \b Function \b Description: This routine is used to set the Treble u8Level of main u8Path.
775 /// @param <IN> \b u8Level : Treble u8Level (0~100) mapping to -16~+15dB
776 /// @param <OUT> \b NONE :
777 /// @param <RET> \b NONE :
778 /// @param <GLOBAL> \b NONE :
779 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetBass(void)780 MS_U16 HAL_SOUND_GetBass(void)
781 {
782 MS_U16 value = 0;
783
784 value = HAL_AUDIO_ReadByte(REG_SOUND_BASS);
785 return value;
786 }
787
788 ////////////////////////////////////////////////////////////////////////////////
789 /// @brief \b Function \b Name: HAL_SOUND_AbsoluteBass() @@VVV
790 /// @brief \b Function \b Description: This routine is used to set the absolute Bass u8Value of main u8Path .
791 /// @param <IN> \b bass : -16~+15dB
792 /// @param <OUT> \b NONE :
793 /// @param <RET> \b NONE :
794 /// @param <GLOBAL> \b NONE :
795 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_AbsoluteBass(MS_U8 u8Bass)796 void HAL_SOUND_AbsoluteBass(MS_U8 u8Bass)
797 {
798 HAL_AUDIO_WriteByte(REG_SOUND_BASS, u8Bass);
799 }
800
801 ////////////////////////////////////////////////////////////////////////////////
802 /// @brief \b Function \b Name: HAL_SOUND_SetTreble() @@VVV
803 /// @brief \b Function \b Description: This routine is used to set the Treble u8Level of main u8Path.
804 /// @param <IN> \b u8Level : Treble u8Level (0~100) mapping to -16~+15dB
805 /// @param <OUT> \b NONE :
806 /// @param <RET> \b NONE :
807 /// @param <GLOBAL> \b NONE :
808 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetTreble(MS_U8 u8Level)809 void HAL_SOUND_SetTreble(MS_U8 u8Level)
810 {
811 int u8Value;
812
813 if(u8Level==100)
814 {
815 u8Value = 0x30;
816 }
817 else
818 {
819 u8Value = ((int)u8Level-50)*48/50; //16/50;
820 }
821
822 DBG_SOUND(printf("Treble:%d",u8Level));
823 DBG_SOUND(printf("==>%x\r\n",u8Value));
824
825 HAL_AUDIO_WriteByte(REG_SOUND_TREBLE, (MS_U8)u8Value);
826 }
827
828 ////////////////////////////////////////////////////////////////////////////////
829 /// @brief \b Function \b Name: HAL_SOUND_GetTreble()
830 /// @brief \b Function \b Description: This routine is used to set the Treble u8Level of main u8Path.
831 /// @param <IN> \b u8Level : Treble u8Level (0~100) mapping to -16~+15dB
832 /// @param <OUT> \b NONE :
833 /// @param <RET> \b NONE :
834 /// @param <GLOBAL> \b NONE :
835 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetTreble(void)836 MS_U16 HAL_SOUND_GetTreble(void)
837 {
838 MS_U16 value = 0;
839
840 value = HAL_AUDIO_ReadByte(REG_SOUND_TREBLE);
841 return value;
842 }
843 ////////////////////////////////////////////////////////////////////////////////
844 /// @brief \b Function \b Name: HAL_SOUND_AbsoluteTreble() @@VVV
845 /// @brief \b Function \b Description: This routine is used to set the absolute Treble u8Value of main u8Path .
846 /// @param <IN> \b treble : -16~+15dB
847 /// @param <OUT> \b NONE :
848 /// @param <RET> \b NONE :
849 /// @param <GLOBAL> \b NONE :
850 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_AbsoluteTreble(MS_U8 u8Treble)851 void HAL_SOUND_AbsoluteTreble(MS_U8 u8Treble)
852 {
853 HAL_AUDIO_WriteByte(REG_SOUND_TREBLE, u8Treble);
854 }
855
856 ////////////////////////////////////////////////////////////////////////////////
857 /// @brief \b Function \b Name: HAL_SOUND_SetEq() @@VVV
858 /// @brief \b Function \b Description: This routine is used to set the the 5-band EQ u8Level .
859 /// @param <IN> \b band : EQ band 0~4
860 /// @param <IN> \b u8Level : Absolute EQ register u8Value
861 /// @param <OUT> \b NONE :
862 /// @param <RET> \b NONE :
863 /// @param <GLOBAL> \b NONE :
864 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetEq(MS_U8 u8Band,MS_U8 u8Level)865 void HAL_SOUND_SetEq(MS_U8 u8Band, MS_U8 u8Level)
866 {
867 MS_U8 value;
868
869 if( u8Band>4)
870 {
871 return;
872 }
873
874 if(u8Level>=100)
875 {
876 value = 0x30;
877 }
878 else
879 {
880 value = ((int)u8Level-50)*48/50;
881 }
882
883 HAL_AUDIO_WriteByte(REG_SOUND_EQ1 + (u8Band*2), value);
884 }
885
886 ////////////////////////////////////////////////////////////////////////////////
887 /// @brief \b Function \b Name: HAL_SOUND_GetEq()
888 /// @brief \b Function \b Description: This routine is used to set the the 5-band EQ u8Level .
889 /// @param <IN> \b band : EQ band 0~4
890 /// @param <IN> \b u8Level : Absolute EQ register u8Value
891 /// @param <OUT> \b NONE :
892 /// @param <RET> \b NONE :
893 /// @param <GLOBAL> \b NONE :
894 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetEq(MS_U8 u8Band)895 MS_U16 HAL_SOUND_GetEq(MS_U8 u8Band)
896 {
897 MS_U16 value = 0;
898
899 value = HAL_AUDIO_ReadByte(REG_SOUND_EQ1 + (u8Band*2));
900 return value;
901 }
902 ////////////////////////////////////////////////////////////////////////////////
903 /// @brief \b Function \b Name: HAL_SOUND_SetEq7() @@VVV
904 /// @brief \b Function \b Description: This routine is used to set the the 7-band EQ u8Level .
905 /// @param <IN> \b u8Band : EQ band 0~6
906 /// @param <IN> \b u8Level : Absolute EQ register u8Value
907 /// @param <OUT> \b NONE :
908 /// @param <RET> \b NONE :
909 /// @param <GLOBAL> \b NONE :
910 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetEq7(MS_U8 u8Band,MS_U8 u8Level)911 void HAL_SOUND_SetEq7(MS_U8 u8Band, MS_U8 u8Level)
912 {
913 MS_U8 value;
914
915 if( u8Band>6)
916 return;
917
918 if(u8Level==100)
919 value = 0x30;
920 else
921 value = ((int)u8Level-50)*48/50;
922
923 HAL_AUDIO_WriteByte(REG_SOUND_EQ_BASE + (u8Band*2), value);
924 }
925
926 ////////////////////////////////////////////////////////////////////////////////
927 /// @brief \b Function \b Name: HAL_SOUND_SetADCThreshold() @@VVV
928 /// @brief \b Function \b Description: This routine is used to set the ADC input energy threshold to reduce the background noise .
929 /// @param <IN> \b u8Threshold : NR threshold u8Level
930 /// @param <OUT> \b NONE :
931 /// @param <RET> \b NONE :
932 /// @param <GLOBAL> \b NONE :
933 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetADCThreshold(MS_U8 u8Threshold)934 void HAL_SOUND_SetADCThreshold(MS_U8 u8Threshold)
935 {
936 HAL_AUDIO_WriteByte(REG_SOUND_NR_THRESHOLD, u8Threshold);
937 }
938
939 ////////////////////////////////////////////////////////////////////////////////
940 /// @brief \b Function \b Name: HAL_SOUND_SetDRCThreshold() @@VVV
941 /// @brief \b Function \b Description: This routine is used to set the DRC threshold u8Level.
942 /// @param <IN> \b u8Threshold : DRC threshold u8Level
943 /// 0x00-- 0 dBFS
944 /// 0x01-- -0.5 dBFS
945 /// 0x20-- -16 dBFS
946 /// 0x50-- -40 dBFS
947 /// @param <OUT> \b NONE :
948 /// @param <RET> \b NONE :
949 /// @param <GLOBAL> \b NONE :
950 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetDRCThreshold(MS_U8 u8Level)951 void HAL_SOUND_SetDRCThreshold(MS_U8 u8Level)
952 {
953 if (u8Level >= 0x50)
954 u8Level = 0x50;
955
956 HAL_AUDIO_WriteByte(REG_SOUND_DRC_THRESHOLD,u8Level);
957 }
958
959
960 ////////////////////////////////////////////////////////////////////////////////
961 /// @brief \b Function \b Name: HAL_SOUND_SetAVCThreshold() @@VVV
962 /// @brief \b Function \b Description: This routine is used to set the AVC threshold u8Level.
963 /// @param <IN> \b u8Threshold : AVC threshold u8Level
964 /// 0x00-- 0 dBFS
965 /// 0x01-- -0.5 dBFS
966 /// 0x20-- -16 dBFS
967 /// 0x50-- -40 dBFS
968 /// @param <OUT> \b NONE :
969 /// @param <RET> \b NONE :
970 /// @param <GLOBAL> \b NONE :
971 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAVCThreshold(MS_U8 u8Level)972 void HAL_SOUND_SetAVCThreshold(MS_U8 u8Level)
973 {
974 if (u8Level >= 0x50)
975 u8Level = 0x50;
976
977 HAL_AUDIO_WriteByte(REG_SOUND_AVC_THRESHOLD,u8Level);
978 }
979
980 ////////////////////////////////////////////////////////////////////////////////
981 /// @brief \b Function \b Name: HAL_SOUND_GetAVCThreshold()
982 /// @brief \b Function \b Description: This routine is used to set the AVC threshold u8Level.
983 /// @param <IN> \b NONE
984 /// @param <OUT> \b Threshold value :
985 /// @param <RET> \b NONE :
986 /// @param <GLOBAL> \b NONE :
987 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetAVCThreshold(void)988 MS_U16 HAL_SOUND_GetAVCThreshold(void)
989 {
990 return(HAL_AUDIO_SeReadByte(REG_SOUND_AVC_THRESHOLD));
991 }
992
993 ////////////////////////////////////////////////////////////////////////////////
994 /// @brief \b Function \b Name: HAL_SOUND_SetAvcMode() @@VVV
995 /// @brief \b Function \b Description: This routine is used to set the AVC mode.
996 /// @param <IN> \b u8AvcMode : AVC threshold u8Level
997 /// 0: L mode
998 /// 1: S mode
999 /// 2: M mode
1000 /// @param <OUT> \b NONE :
1001 /// @param <RET> \b NONE :
1002 /// @param <GLOBAL> \b NONE :
1003 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAvcMode(MS_U8 u8AvcMode)1004 void HAL_SOUND_SetAvcMode(MS_U8 u8AvcMode )
1005 {
1006 switch(u8AvcMode)
1007 {
1008 case 0:
1009 HAL_AUDIO_WriteMaskByte(REG_SOUND_AVC_MODE ,0x03 ,0x00);
1010 break;
1011 case 1:
1012 HAL_AUDIO_WriteMaskByte(REG_SOUND_AVC_MODE ,0x03 ,0x01);
1013 break;
1014 case 2:
1015 HAL_AUDIO_WriteMaskByte(REG_SOUND_AVC_MODE ,0x03 ,0x02);
1016 break;
1017 default:
1018 break;
1019 }
1020 }
1021
1022
1023 ////////////////////////////////////////////////////////////////////////////////
1024 /// @brief \b Function \b Name: HAL_SOUND_GetAvcMode()
1025 /// @brief \b Function \b Description: This routine is used to set the AVC mode.
1026 /// @param <RET> \b u8AvcMode : AVC threshold u8Level
1027 /// 0: L mode
1028 /// 1: S mode
1029 /// 2: M mode
1030 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetAvcMode(void)1031 MS_U16 HAL_SOUND_GetAvcMode(void)
1032 {
1033 return(HAL_AUDIO_ReadByte(REG_SOUND_AVC_MODE)&0x03);
1034 }
1035
1036 ////////////////////////////////////////////////////////////////////////////////
1037 /// @brief \b Function \b Name: HAL_SOUND_SetAvcAT() @@VVV
1038 /// @brief \b Function \b Description: This routine is used to set the AVC attack time .
1039 /// @param <IN> \b u8AvcAT : AVC attack time
1040 /// AvcAT = 0 --> 2 sec
1041 /// AvcAT = 1 --> 1 sec
1042 /// AvcAT = 2 --> 500 ms
1043 /// AvcAT = 3 --> 400 ms
1044 /// AvcAT = 4 --> 300 ms
1045 /// AvcAT = 5 --> 200 ms
1046 /// AvcAT = 6 --> 100 ms
1047 /// AvcAT = 7 --> 20 ms
1048 /// @param <OUT> \b NONE :
1049 /// @param <RET> \b NONE :
1050 /// @param <GLOBAL> \b NONE :
1051 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAvcAT(MS_U8 u8AvcAT)1052 void HAL_SOUND_SetAvcAT(MS_U8 u8AvcAT )
1053 {
1054 if(u8AvcAT>7)
1055 u8AvcAT=7;
1056
1057 HAL_AUDIO_WriteMaskByte(REG_SOUND_AVC_AT ,0xE0 ,(u8AvcAT<<5));
1058 }
1059
1060
1061 ////////////////////////////////////////////////////////////////////////////////
1062 /// @brief \b Function \b Name: HAL_SOUND_GetAvcAT()
1063 /// @brief \b Function \b Description: This routine is used to set the AVC mode.
1064 /// @param <RET>
1065 /// AvcAT = 0 --> 2 sec
1066 /// AvcAT = 1 --> 1 sec
1067 /// AvcAT = 2 --> 500 ms
1068 /// AvcAT = 3 --> 400 ms
1069 /// AvcAT = 4 --> 300 ms
1070 /// AvcAT = 5 --> 200 ms
1071 /// AvcAT = 6 --> 100 ms
1072 /// AvcAT = 7 --> 20 ms
1073 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetAvcAT(void)1074 MS_U16 HAL_SOUND_GetAvcAT(void)
1075 {
1076 return((HAL_AUDIO_ReadByte(REG_SOUND_AVC_AT)&0xE0)>>5);
1077 }
1078 ////////////////////////////////////////////////////////////////////////////////
1079 /// @brief \b Function \b Name: HAL_SOUND_SetAvcRT() @@VVV
1080 /// @brief \b Function \b Description: This routine is used to set the AVC release time .
1081 /// @param <IN> \b u8AvcRT : AVC release time
1082 /// u8AvcRT = 0 --> 2 sec
1083 /// u8AvcRT = 1 --> 1 sec
1084 /// u8AvcRT = 2 --> 500 ms
1085 /// u8AvcRT = 3 --> 400 ms
1086 /// u8AvcRT = 4 --> 300 ms
1087 /// u8AvcRT = 5 --> 200 ms
1088 /// u8AvcRT = 6 --> 100 ms
1089 /// u8AvcRT = 7 --> 20 ms
1090 /// @param <OUT> \b NONE :
1091 /// @param <RET> \b NONE :
1092 /// @param <GLOBAL> \b NONE :
1093 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAvcRT(MS_U8 u8AvcRT)1094 void HAL_SOUND_SetAvcRT(MS_U8 u8AvcRT )
1095 {
1096 if(u8AvcRT>7)
1097 u8AvcRT=7;
1098
1099 HAL_AUDIO_WriteMaskByte(REG_SOUND_AVC_RT ,0x1C ,(u8AvcRT<<2));
1100 }
1101
1102 ////////////////////////////////////////////////////////////////////////////////
1103 /// @brief \b Function \b Name: HAL_SOUND_GetAvcRT()
1104 /// @brief \b Function \b Description: This routine is used to set the AVC mode.
1105 /// @param <RET> \b u8AvcRT : AVC release time
1106 /// u8AvcRT = 0 --> 2 sec
1107 /// u8AvcRT = 1 --> 1 sec
1108 /// u8AvcRT = 2 --> 500 ms
1109 /// u8AvcRT = 3 --> 400 ms
1110 /// u8AvcRT = 4 --> 300 ms
1111 /// u8AvcRT = 5 --> 200 ms
1112 /// u8AvcRT = 6 --> 100 ms
1113 /// u8AvcRT = 7 --> 20 ms
1114 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetAvcRT(void)1115 MS_U16 HAL_SOUND_GetAvcRT(void)
1116 {
1117 MS_U16 Mode=0;
1118
1119 Mode = (HAL_AUDIO_ReadByte(REG_SOUND_AVC_RT)&0x1C) >> 2;
1120 return Mode;
1121 }
1122
1123 ////////////////////////////////////////////////////////////////////////////////
1124 /// @brief \b Function \b Name: HAL_SOUND_EnableEaseVol() @@VVV
1125 /// @brief \b Function \b Description: This routine is used to bEnable/disable the EaseVol featue.
1126 /// @param <IN> \b bEnable : TRUE -- Enable EaseVol
1127 /// FALSE -- Disable EaseVol
1128 /// @param <OUT> \b NONE :
1129 /// @param <RET> \b NONE :
1130 /// @param <GLOBAL> \b NONE :
1131 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableEaseVol(MS_BOOL bEnable)1132 void HAL_SOUND_EnableEaseVol(MS_BOOL bEnable)
1133 {
1134 HAL_AUDIO_WriteMaskByte(0x2D20, 0x40, bEnable<<6);
1135 }
1136
1137 ////////////////////////////////////////////////////////////////////////////////
1138 /// @brief \b Function \b Name: HAL_SOUND_EnableEQ() @@VVV
1139 /// @brief \b Function \b Description: This routine is used to bEnable/disable EQ featue.
1140 /// @param <IN> \b bEnable : TRUE --Enable EQ
1141 /// FALSE--Disable EQ
1142 /// @param <OUT> \b NONE :
1143 /// @param <RET> \b NONE :
1144 /// @param <GLOBAL> \b NONE :
1145 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableEQ(MS_BOOL bEnable)1146 void HAL_SOUND_EnableEQ(MS_BOOL bEnable)
1147 {
1148 HAL_AUDIO_WriteMaskByte(0x2D20, 0x80, bEnable<<7);
1149 }
1150
1151 ////////////////////////////////////////////////////////////////////////////////
1152 /// @brief \b Function \b Name: HAL_SOUND_GetEQ_Status()
1153 /// @brief \b Function \b Description: This routine is used to get the EQ is enable or not
1154 /// @param <IN> \b NONE :
1155 /// @param <OUT> \b NONE :
1156 /// @param <RET> \b bEnable : TRUE --Enable EQ
1157 /// FALSE--Disable EQ
1158 /// @param <GLOBAL> \b NONE :
1159 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetEQ_Status(void)1160 MS_U16 HAL_SOUND_GetEQ_Status(void)
1161 {
1162 if((HAL_AUDIO_ReadByte(0x2D20)&0x80) == 0x80)
1163 {
1164 return 1;
1165 }else{
1166 return 0;
1167 }
1168 }
1169
1170 ////////////////////////////////////////////////////////////////////////////////
1171 /// @brief \b Function \b Name: HAL_SOUND_EnableSurround() @@VVV
1172 /// @brief \b Function \b Description: This routine is used to bEnable/disable Surround featue.
1173 /// @param <IN> \b bEnable : TRUE --Enable Surround
1174 /// FALSE--Disable Surround
1175 /// @param <OUT> \b NONE :
1176 /// @param <RET> \b NONE :
1177 /// @param <GLOBAL> \b NONE :
1178 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableSurround(MS_BOOL bEnable)1179 void HAL_SOUND_EnableSurround(MS_BOOL bEnable)
1180 {
1181 HAL_AUDIO_WriteMaskByte(0x2D21, 0x04, bEnable<<2);
1182 }
1183
1184 ////////////////////////////////////////////////////////////////////////////////
1185 /// @brief \b Function \b Name: HAL_SOUND_GetSurround_Status()
1186 /// @brief \b Function \b Description: This routine is used to get the Surround is enable or not
1187 /// @param <IN> \b NONE :
1188 /// @param <OUT> \b NONE :
1189 /// @param <RET> \b bEnable : TRUE --Enable Surround
1190 /// FALSE--Disable Surround
1191 /// @param <GLOBAL> \b NONE :
1192 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetSurround_Status(void)1193 MS_U16 HAL_SOUND_GetSurround_Status(void)
1194 {
1195 if((HAL_AUDIO_ReadByte(0x2D21)&0x04) == 0x04)
1196 {
1197 return 1;
1198 }else{
1199 return 0;
1200 }
1201 }
1202
1203 ////////////////////////////////////////////////////////////////////////////////
1204 /// @brief \b Function \b Name: HAL_SOUND_EnableTone() @@VVV
1205 /// @brief \b Function \b Description: This routine is used to bEnable/disable the treble & Bass featue.
1206 /// @param <IN> \b bEnable : TRUE --Enable Tone
1207 /// FALSE--Disable Tone
1208 /// @param <OUT> \b NONE :
1209 /// @param <RET> \b NONE :
1210 /// @param <GLOBAL> \b NONE :
1211 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableTone(MS_BOOL bEnable)1212 void HAL_SOUND_EnableTone(MS_BOOL bEnable)
1213 {
1214 HAL_AUDIO_WriteMaskByte(0x2D21, 0x08, bEnable<<3);
1215 }
1216
1217 ////////////////////////////////////////////////////////////////////////////////
1218 /// @brief \b Function \b Name: HAL_SOUND_GetTone_Status()
1219 /// @brief \b Function \b Description: This routine is used to get the Tone is enable or not
1220 /// @param <IN> \b NONE :
1221 /// @param <OUT> \b NONE :
1222 /// @param <RET> \b bEnable : TRUE --Enable Tone
1223 /// FALSE--Disable Tone
1224 /// @param <GLOBAL> \b NONE :
1225 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetTone_Status(void)1226 MS_U16 HAL_SOUND_GetTone_Status(void)
1227 {
1228 if((HAL_AUDIO_ReadByte(0x2D21)&0x08) == 0x08)
1229 {
1230 return 1;
1231 }
1232 else
1233 {
1234 return 0;
1235 }
1236 }
1237
1238 ////////////////////////////////////////////////////////////////////////////////
1239 /// @brief \b Function \b Name: HAL_SOUND_EnableDRC() @@VVV
1240 /// @brief \b Function \b Description: This routine is used to bEnable/disable the DRC featue.
1241 /// @param <IN> \b bEnable : TRUE --Enable DRC
1242 /// FALSE--Disable DRC
1243 /// @param <OUT> \b NONE :
1244 /// @param <RET> \b NONE :
1245 /// @param <GLOBAL> \b NONE :
1246 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableDRC(MS_BOOL bEnable)1247 void HAL_SOUND_EnableDRC(MS_BOOL bEnable)
1248 {
1249 HAL_AUDIO_WriteMaskByte(0x2D21, 0x20, bEnable<<5);
1250 }
1251
1252 ////////////////////////////////////////////////////////////////////////////////
1253 /// @brief \b Function \b Name: HAL_SOUND_EnableAutoVolume() @@VVV
1254 /// @brief \b Function \b Description: This routine is used to bEnable/disable the AVC featue.
1255 /// @param <IN> \b bEnable : TRUE --Enable AutoVolume
1256 /// FALSE--Disable AutoVolume
1257 /// @param <OUT> \b NONE :
1258 /// @param <RET> \b NONE :
1259 /// @param <GLOBAL> \b NONE :
1260 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableAutoVolume(MS_BOOL bEnable)1261 void HAL_SOUND_EnableAutoVolume(MS_BOOL bEnable)
1262 {
1263 HAL_AUDIO_WriteMaskByte(0x2D21, 0x10, bEnable<<4);
1264 }
1265
1266 ////////////////////////////////////////////////////////////////////////////////
1267 /// @brief \b Function \b Name: HAL_SOUND_GetAutoVolume_Status()
1268 /// @brief \b Function \b Description: This routine is used to get the AutoVolume is enable or not
1269 /// @param <IN> \b NONE :
1270 /// @param <OUT> \b NONE :
1271 /// @param <RET> \b bEnable : TRUE --Enable AutoVolume
1272 /// FALSE--Disable AutoVolume
1273 /// @param <GLOBAL> \b NONE :
1274 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetAutoVolume_Status(void)1275 MS_U16 HAL_SOUND_GetAutoVolume_Status(void)
1276 {
1277 if((HAL_AUDIO_ReadByte(0x2D21)&0x10) == 0x10)
1278 {
1279 return 1;
1280 }
1281 else
1282 {
1283 return 0;
1284 }
1285 }
1286
1287
1288 ////////////////////////////////////////////////////////////////////////////////
1289 /// @brief \b Function \b Name: HAL_SOUND_EnableNR()
1290 /// @brief \b Function \b Description: This routine is used to bEnable/disable the Noise Reduction featue.
1291 /// @param <IN> \b bEnable : TRUE --Enable NR
1292 /// FALSE--Disable NR
1293 /// @param <OUT> \b NONE :
1294 /// @param <RET> \b NONE :
1295 /// @param <GLOBAL> \b NONE :
1296 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableNR(MS_U8 u8Level)1297 void HAL_SOUND_EnableNR(MS_U8 u8Level)
1298 {
1299 HAL_AUDIO_WriteMaskByte(0x2D32, 0xFF, u8Level); // dm (IO_102);!2D24[0,7]
1300 }
1301
1302 ////////////////////////////////////////////////////////////////////////////////
1303 /// @brief \b Function \b Name: HAL_SOUND_SetNRAttenuate()
1304 /// @brief \b Function \b Description: This routine is used to set the attenuate u8Level while NR is bEnabled.
1305 /// @param <IN> \b u8Mode : 0 : Auto fading to -24 dB
1306 /// 1 : Auto fading to -24 dB
1307 /// 2 : Auto fading to -24 dB
1308 /// 3 : Auto fading to -24 dB
1309 /// @param <OUT> \b NONE :
1310 /// @param <RET> \b NONE :
1311 /// @param <GLOBAL> \b NONE :
1312 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetNRAttenuate(MS_U8 u8Mode)1313 void HAL_SOUND_SetNRAttenuate(MS_U8 u8Mode)
1314 {
1315 UNUSED(u8Mode);
1316 }
1317
1318
1319 ////////////////////////////////////////////////////////////////////////////////
1320 /// @brief \b Function \b Name: HAL_SOUND_EnableKTVEcho() @@VVV
1321 /// @brief \b Function \b Description: This routine is used to bEnable/disable the KTVEcho featue.
1322 /// @param <IN> \b bEnable : TRUE --Enable KTVEcho
1323 /// FALSE--Disable KTVEcho
1324 /// @param <OUT> \b NONE :
1325 /// @param <RET> \b NONE :
1326 /// @param <GLOBAL> \b NONE :
1327 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableKTVEcho(MS_BOOL bEnable)1328 void HAL_SOUND_EnableKTVEcho(MS_BOOL bEnable)
1329 {
1330 HAL_AUDIO_WriteMaskByte(0x2D20, 0x02, bEnable<<1);
1331 }
1332
1333 ////////////////////////////////////////////////////////////////////////////////
1334 /// @brief \b Function \b Name: HAL_SOUND_PowerDown_Wait() @@VVV
1335 /// @brief \b Function \b Description: This routine is used to DSP power-down wait function.
1336 /// @param <IN> \b bEnable : TRUE --Not wait
1337 /// FALSE--wait
1338 /// @param <OUT> \b NONE :
1339 /// @param <RET> \b NONE :
1340 /// @param <GLOBAL> \b NONE :
1341 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_PowerDown_Wait(MS_BOOL bEnable)1342 void HAL_SOUND_PowerDown_Wait(MS_BOOL bEnable)
1343 {
1344 HAL_AUDIO_WriteMaskByte(0x2D31, 0x01, bEnable);
1345 }
1346
1347 ////////////////////////////////////////////////////////////////////////////////
1348 /// @brief \b Function \b Name: HAL_SOUND_SetAdAbsoluteVolume() @@VVV
1349 /// @brief \b Function \b Description: This routine is used to set the absolute volume of AD.
1350 /// @param <IN> \b u8u8Vol1 : MSB 7-bit register u8Value of 10-bit volume
1351 /// range from 0x00 to 0x7E , gain: +12db to -114db (-1 db per step)
1352 /// @param <IN> \b u8u8Vol2 : LSB 3-bit register u8Value of 10-bit volume
1353 /// range from 0x00 to 0x07 , gain: -0db to -0.875db (-0.125 db per step)
1354 /// @param <OUT> \b NONE :
1355 /// @param <RET> \b NONE :
1356 /// @param <GLOBAL> \b NONE :
1357 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAdAbsoluteVolume(MS_U8 u8Vol1,MS_U8 u8Vol2)1358 void HAL_SOUND_SetAdAbsoluteVolume(MS_U8 u8Vol1, MS_U8 u8Vol2)
1359 {
1360 MS_U32 Vol = ((u8Vol1<<3) | (u8Vol2&0x07));
1361 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AD_VOLUME, ADEC1, Vol, 0);
1362 // Vol[10:0] = mute[10]|int[9:3]|fra[2:0]
1363 }
1364
1365 ////////////////////////////////////////////////////////////////////////////////
1366 /// @brief \b Function \b Name: HAL_SOUND_SetAdMute() @@VVV
1367 /// @brief \b Function \b Description: This routine is used to set AD mute.
1368 /// @param <IN> \b bEnable : TRUE --Mute AD
1369 /// FALSE--Unmute AD
1370 /// @param <OUT> \b NONE :
1371 /// @param <RET> \b NONE :
1372 /// @param <GLOBAL> \b NONE :
1373 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetAdMute(MS_BOOL bEnable)1374 void HAL_SOUND_SetAdMute(MS_BOOL bEnable)
1375 {
1376 HAL_DEC_R2_Set_SHM_PARAM(R2_SHM_PARAM_AD_VOLUME_MUTE, ADEC1, bEnable, 0);
1377 }
1378
1379 ////////////////////////////////////////////////////////////////////////////////
1380 /// @brief \b Function \b Name: HAL_SOUND_SetCH1AudioDelay()
1381 /// @brief \b Function \b Description: This routine is used to set the u8Value of audio delay.
1382 /// @param <IN> \b delay : 0x20~0xC8(32~200), in ms unit
1383 /// @param <OUT> \b NONE :
1384 /// @param <RET> \b NONE :
1385 /// @param <GLOBAL> \b NONE :
1386 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetCH1AudioDelay(MS_U16 u16Delay)1387 void HAL_SOUND_SetCH1AudioDelay(MS_U16 u16Delay)
1388 {
1389 if (u16Delay > AUDIO_DELAY_UPPER_BOUND)
1390 {
1391 printf("Warning! Invalid value (%u), main audio delay should be less than %u ms. \r\n", u16Delay, AUDIO_DELAY_UPPER_BOUND);
1392 u16Delay = AUDIO_DELAY_UPPER_BOUND;
1393 }
1394
1395 if (u16Delay < AUDIO_DELAY_LOWER_BOUND)
1396 {
1397 printf("Warning! Invalid value (%u), main audio delay should be great than %u ms. \r\n", u16Delay, AUDIO_DELAY_LOWER_BOUND);
1398 u16Delay = AUDIO_DELAY_LOWER_BOUND;
1399 }
1400
1401 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_mainAudioDelay, u16Delay);
1402 }
1403
1404 ////////////////////////////////////////////////////////////////////////////////
1405 /// @brief \b Function \b Name: HAL_SOUND_GetCH1AudioDelay()
1406 /// @brief \b Function \b Description: This routine is used to set the u8Value of audio delay.
1407 /// @param <RET> \b delay : 0x14~0xC8(20~200), in ms unit
1408 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetCH1AudioDelay(void)1409 MS_U16 HAL_SOUND_GetCH1AudioDelay(void)
1410 {
1411 return((MS_U16)HAL_MAD2_Read_DSP_Xbox(DSP2XboxAddr_mainAudioDelay));
1412 }
1413
1414
1415 ////////////////////////////////////////////////////////////////////////////////
1416 /// @brief \b Function \b Name: HAL_SOUND_SetSpdifAudioDelay()
1417 /// @brief \b Function \b Description: This routine is used to set the u8Value of spdif delay.
1418 /// @param <IN> \b delay : 0x14~0xFA(20~250), in ms unit
1419 /// @param <OUT> \b NONE :
1420 /// @param <RET> \b NONE :
1421 /// @param <GLOBAL> \b NONE :
1422 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetSpdifAudioDelay(MS_U16 u16Delay)1423 void HAL_SOUND_SetSpdifAudioDelay(MS_U16 u16Delay)
1424 {
1425 if (u16Delay > SPDIF_DELAY_UPPER_BOUND)
1426 {
1427 printf("Warning! Invalid value (%u), spdif audio delay should be less than %u ms. \r\n", u16Delay, SPDIF_DELAY_UPPER_BOUND);
1428 u16Delay = SPDIF_DELAY_UPPER_BOUND;
1429 }
1430
1431 if (u16Delay < SPDIF_DELAY_LOWER_BOUND)
1432 {
1433 printf("Warning! Invalid value (%u), spdif audio delay should be great than %u ms. \r\n", u16Delay, SPDIF_DELAY_LOWER_BOUND);
1434 u16Delay = SPDIF_DELAY_LOWER_BOUND;
1435 }
1436
1437 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_spdifDelay, u16Delay);
1438 }
1439
1440 ////////////////////////////////////////////////////////////////////////////////
1441 /// @brief \b Function \b Name: HAL_SOUND_SetHdmiAudioDelay()
1442 /// @brief \b Function \b Description: This routine is used to set the u8Value of independent hdmi delay.
1443 /// @param <IN> \b delay : 0x14~0xFA(20~250), in ms unit
1444 /// @param <OUT> \b NONE :
1445 /// @param <RET> \b NONE :
1446 /// @param <GLOBAL> \b NONE :
1447 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetHdmiAudioDelay(MS_U16 u16Delay)1448 void HAL_SOUND_SetHdmiAudioDelay(MS_U16 u16Delay)
1449 {
1450 if (u16Delay > HDMI_DELAY_UPPER_BOUND)
1451 {
1452 printf("Warning! Invalid value (%u), hdmi audio delay should be less than %u ms. \r\n", u16Delay, HDMI_DELAY_UPPER_BOUND);
1453 u16Delay = HDMI_DELAY_UPPER_BOUND;
1454 }
1455
1456 if (u16Delay < HDMI_DELAY_LOWER_BOUND)
1457 {
1458 printf("Warning! Invalid value (%u), hdmi audio delay should be great than %u ms. \r\n", u16Delay, HDMI_DELAY_LOWER_BOUND);
1459 u16Delay = HDMI_DELAY_LOWER_BOUND;
1460 }
1461
1462 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hdmiDelay, u16Delay);
1463
1464 }
1465 ////////////////////////////////////////////////////////////////////////////////
1466 /// @brief \b Function \b Name: HAL_SOUND_SetMenuSound() @@Need_Modify
1467 /// @brief \b Function \b Description: This routine is used to Play Menu Sound.
1468 /// @param <IN> \b NONE :
1469 /// @param <OUT> \b NONE :
1470 /// @param <RET> \b NONE :
1471 /// @param <GLOBAL> \b NONE :
1472 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_PlayMenuSound(void)1473 void HAL_SOUND_PlayMenuSound(void)
1474 {
1475 /*Cathy0721
1476 HAL_AUDIO_WriteMaskByte(0x2DAE, 0x01, 0x01);
1477 AUDIO_DELAY1MS(10);
1478 HAL_AUDIO_WriteMaskByte(0x2DAE, 0x01, 0x00);*/
1479 }
1480
1481 ////////////////////////////////////////////////////////////////////////////////
1482 /// @brief \b Function \b Name: HAL_SOUND_SetSurroundXA() @@VVV
1483 /// @brief \b Function \b Description: This routine is used to set the Surround xA Gain.
1484 /// @param <IN> \b u8Mode : 0 : 0.1 xA : 0x2D8A[3:2] 00: 0.1
1485 /// 1 : 0.15 01: 0.15
1486 /// 2 : 0.2 10: 0.2
1487 /// 3 : 0.25 11: 0.25
1488 /// @param <OUT> \b NONE :
1489 /// @param <RET> \b NONE :
1490 /// @param <GLOBAL> \b NONE
1491 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetSurroundXA(MS_U8 u8Mode)1492 void HAL_SOUND_SetSurroundXA(MS_U8 u8Mode)
1493 {
1494 switch(u8Mode)
1495 {
1496 case 0:
1497 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x0C ,0x00);
1498 break;
1499 case 1:
1500 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x0C ,0x04);
1501 break;
1502 case 2:
1503 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x0C ,0x08);
1504 break;
1505 case 3:
1506 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x0C ,0x0C);
1507 break;
1508 default:
1509 break;
1510 }
1511 }
1512
1513 ////////////////////////////////////////////////////////////////////////////////
1514 /// @brief \b Function \b Name: HAL_SOUND_GetSurroundXA()
1515 /// @brief \b Function \b Description: This routine is used to set the Surround xA Gain.
1516 /// @param <RET> MODE \b u8Mode : 0 : 0.1 xA : 0x2D8A[3:2] 00: 0.1
1517 /// 1 : 0.15 01: 0.15
1518 /// 2 : 0.2 10: 0.2
1519 /// 3 : 0.25 11: 0.25
1520 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetSurroundXA(void)1521 MS_U16 HAL_SOUND_GetSurroundXA(void)
1522 {
1523 return((HAL_AUDIO_ReadByte(0x2D26)&0x0C)>>2);
1524 }
1525
1526 ////////////////////////////////////////////////////////////////////////////////
1527 /// @brief \b Function \b Name: HAL_SOUND_SetSurroundXB() @@VVV
1528 /// @brief \b Function \b Description: This routine is used to set the Surround xB Gain.
1529 /// @param <IN> \b u8Mode : 0 : 0.25 xB : 0x2D8A[5:4] 00: 0.25
1530 /// 1 : 0.3 01: 0.3
1531 /// 2 : 0.35 10: 0.35
1532 /// 3 : 0.45 11: 0.45
1533 /// @param <OUT> \b NONE :
1534 /// @param <RET> \b NONE :
1535 /// @param <GLOBAL> \b NONE
1536 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetSurroundXB(MS_U8 u8Mode)1537 void HAL_SOUND_SetSurroundXB(MS_U8 u8Mode)
1538 {
1539 switch(u8Mode)
1540 {
1541 case 0:
1542 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x30 ,0x00);
1543 break;
1544 case 1:
1545 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x30 ,0x10);
1546 break;
1547 case 2:
1548 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x30 ,0x20);
1549 break;
1550 case 3:
1551 HAL_AUDIO_WriteMaskByte(0x2D26 ,0x30 ,0x30);
1552 break;
1553 default:
1554 break;
1555 }
1556 }
1557
1558 ////////////////////////////////////////////////////////////////////////////////
1559 /// @brief \b Function \b Name: HAL_SOUND_GetSurroundXB()
1560 /// @brief \b Function \b Description: This routine is used to set the Surround xB Gain.
1561 /// @param <RET> MODE \b u8Mode : 0 : 0.1 xB : 0x2D8A[3:2] 00: 0.1
1562 /// 1 : 0.15 01: 0.15
1563 /// 2 : 0.2 10: 0.2
1564 /// 3 : 0.25 11: 0.25
1565 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetSurroundXB(void)1566 MS_U16 HAL_SOUND_GetSurroundXB(void)
1567 {
1568 return((HAL_AUDIO_ReadByte(0x2D26)&0x30)>>2);
1569 }
1570
1571 ////////////////////////////////////////////////////////////////////////////////
1572 /// @brief \b Function \b Name: HAL_SOUND_SetSurroundXK() @@VVV
1573 /// @brief \b Function \b Description: This routine is used to set the Surround xK Gain.
1574 /// @param <IN> \b u8Mode : 0 : 0.1 xK : 0x2D8A[7:6] 00: 0.1
1575 /// 1 : 0.2 01: 0.2
1576 /// 2 : 0.3 10: 0.3
1577 /// 3 : 0.4 11: 0.4
1578 /// @param <OUT> \b NONE :
1579 /// @param <RET> \b NONE :
1580 /// @param <GLOBAL> \b NONE
1581 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetSurroundXK(MS_U8 u8Mode)1582 void HAL_SOUND_SetSurroundXK(MS_U8 u8Mode)
1583 {
1584 HAL_AUDIO_WriteMaskByte(0x2D27 ,0x07 ,u8Mode);
1585 }
1586
1587 ////////////////////////////////////////////////////////////////////////////////
1588 /// @brief \b Function \b Name: HAL_SOUND_GetSurroundXK()
1589 /// @brief \b Function \b Description: This routine is used to set the Surround xK Gain.
1590 /// @param <RET> MODE \b u8Mode : 0 : 0.1 xK : 0x2D27[2:0] 00: 0.1
1591 /// 1 : 0.2 01: 0.2
1592 /// 2 : 0.3 10: 0.3
1593 /// 3 : 0.4 11: 0.4
1594 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetSurroundXK(void)1595 MS_U16 HAL_SOUND_GetSurroundXK(void)
1596 {
1597 MS_U16 Mode=0;
1598
1599 Mode = HAL_AUDIO_ReadByte(0x2D27)&0x07;
1600
1601 return Mode;
1602 }
1603
1604 ////////////////////////////////////////////////////////////////////////////////
1605 /// @brief \b Function \b Name: HAL_SOUND_SetSurroundLPFGain() @@VVV
1606 /// @brief \b Function \b Description: This routine is used to set the Surround LPF Gain.
1607 /// @param <IN> \b u8Mode : 0 : 0 dB LPF Gain : 0x2DA0[7:6] 00: 0 dB
1608 /// 1 : 2 dB 01: 2 dB
1609 /// 2 : 4 dB 10: 4 dB
1610 /// 3 : un-support 11: un-support
1611 /// @param <OUT> \b NONE :
1612 /// @param <RET> \b NONE :
1613 /// @param <GLOBAL> \b NONE
1614 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetSurroundLPFGain(MS_U8 u8Mode)1615 void HAL_SOUND_SetSurroundLPFGain(MS_U8 u8Mode)
1616 {
1617 switch(u8Mode)
1618 {
1619 case 0:
1620 HAL_AUDIO_WriteMaskByte(0x2D26 ,0xC0 ,0x00);
1621 break;
1622 case 1:
1623 HAL_AUDIO_WriteMaskByte(0x2D26 ,0xC0 ,0x40);
1624 break;
1625 case 2:
1626 HAL_AUDIO_WriteMaskByte(0x2D26 ,0xC0 ,0x80);
1627 break;
1628 case 3:
1629 //HAL_AUDIO_WriteMaskByte(0x2D26 ,0xC0 ,0xC0);
1630 break;
1631 default:
1632 break;
1633 }
1634 }
1635
1636 ////////////////////////////////////////////////////////////////////////////////
1637 /// @brief \b Function \b Name: HAL_SOUND_GetSurroundLPFGain()
1638 /// @brief \b Function \b Description: This routine is used to set the Surround xK Gain.
1639 /// @param <RET> \b LPFGain :
1640 // 0 : 0dB
1641 /// 1 : 2dB
1642 /// 2 : 4dB
1643 /// 3 : up-support
1644 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetSurroundLPFGain(void)1645 MS_U16 HAL_SOUND_GetSurroundLPFGain(void)
1646 {
1647 return((HAL_AUDIO_ReadByte(0x2D26)&0xC0)>>6);
1648 }
1649
1650
1651 ////////////////////////////////////////////////////////////////////////////////
1652 /// @brief \b Function \b Name: HAL_SOUND_SetPEQCoef()
1653 /// @brief \b Function \b Description: This routine is used to set PEQ Coefficient.
1654 /// @param <IN> \b peq_coef
1655 /// @param <OUT> \b NONE :
1656 /// @param <RET> \b NONE :
1657 /// @param <GLOBAL> \b NONE
1658 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetPEQCoef(AUDIO_PEQ_COEF * peq_coef)1659 void HAL_SOUND_SetPEQCoef(AUDIO_PEQ_COEF *peq_coef)
1660 {
1661 MS_U16 dsp_addr;
1662 MS_U16 dsp_scale_addr;
1663
1664 if(peq_coef->sfs == 0)
1665 {
1666 DBG_SOUND(printf("!!!only support 48K coefficient ! ! !\n");)
1667 return;
1668 }
1669
1670 //PEQ setting
1671 if(peq_coef->type == AUDIO_COEF_PEQ || peq_coef->type == AUDIO_COEF_PREVER_PEQ) // PEQ setting
1672 {
1673 if(peq_coef->enable == FALSE)
1674 peq_band_enable &= (0xFFFFFFFF ^ ((MS_U32)1<<peq_coef->band));
1675 else
1676 peq_band_enable |= ((MS_U32)1<<peq_coef->band);
1677
1678 if(peq_coef->precision == AUDIO_SINGLE_PRECISION)
1679 peq_band_precision &= (0xFFFFFFFF ^ ((MS_U32)1<<peq_coef->band));
1680 else
1681 peq_band_precision |= ((MS_U32)1<<peq_coef->band);
1682
1683 dsp_addr = DSP2XboxAddr_peq48KCoeffAddr + peq_coef->band*5;
1684 dsp_scale_addr = DSP2XboxAddr_peqscale48KAddr + peq_coef->band;
1685
1686 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT)); //disable updating coefficient to prevent pop
1687 HAL_MAD2_Write_DSP_Xbox(dsp_addr,peq_coef->a0);
1688 HAL_MAD2_Write_DSP_Xbox(dsp_addr+1,peq_coef->a1);
1689 HAL_MAD2_Write_DSP_Xbox(dsp_addr+2,peq_coef->a2);
1690 HAL_MAD2_Write_DSP_Xbox(dsp_addr+3,peq_coef->b1);
1691 HAL_MAD2_Write_DSP_Xbox(dsp_addr+4,peq_coef->b2);
1692 HAL_MAD2_Write_DSP_Xbox(dsp_scale_addr,(MS_U32)peq_coef->scale);
1693 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peqbandEnAddr, peq_band_enable);
1694 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peqbandDoubleAddr, peq_band_precision);
1695 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peqUpdateFlag, 0x1);
1696 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 0x00); //enable coefficient update
1697 }
1698 // HLPF setting
1699 else if(peq_coef->type == AUDIO_COEF_HPF)
1700 {
1701 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT)); //disable updating coefficient to prevent pop
1702 dsp_addr = DSP2XboxAddr_hpf48KCoeffAddr;
1703 HAL_MAD2_Write_DSP_Xbox(dsp_addr,peq_coef->a0);
1704 HAL_MAD2_Write_DSP_Xbox(dsp_addr+1,peq_coef->a1);
1705 HAL_MAD2_Write_DSP_Xbox(dsp_addr+2,peq_coef->a2);
1706 HAL_MAD2_Write_DSP_Xbox(dsp_addr+3,peq_coef->b1);
1707 HAL_MAD2_Write_DSP_Xbox(dsp_addr+4,peq_coef->b2);
1708 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_hpUpdateFlag, 0x1);
1709 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 0x00); //disable oefficient update
1710 }
1711 //TONE setting
1712 else if(peq_coef->type == AUDIO_COEF_BASS ||peq_coef->type == AUDIO_COEF_TREBLE)
1713 {
1714 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT)); //disable updating coefficient to prevent pop
1715 if(peq_coef->type == AUDIO_COEF_BASS)
1716 {
1717 dsp_addr = DSP2XboxAddr_bass48KCoeffAddr;
1718 }
1719 else
1720 {
1721 dsp_addr = DSP2XboxAddr_treble48KCoeffAddr;
1722 dsp_scale_addr =DSP2XboxAddr_treblescale48KAddr;
1723 HAL_MAD2_Write_DSP_Xbox(dsp_scale_addr,(MS_U32)peq_coef->scale);
1724 }
1725 HAL_MAD2_Write_DSP_Xbox(dsp_addr,peq_coef->a0);
1726 HAL_MAD2_Write_DSP_Xbox(dsp_addr+1,peq_coef->a1);
1727 HAL_MAD2_Write_DSP_Xbox(dsp_addr+2,peq_coef->a2);
1728 HAL_MAD2_Write_DSP_Xbox(dsp_addr+3,peq_coef->b1);
1729 HAL_MAD2_Write_DSP_Xbox(dsp_addr+4,peq_coef->b2);
1730 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_toneSelectAddr,0x01);
1731 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_toneUpdateFlag, 0x1);
1732 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_trebleUpdateFlag, 0x1);
1733 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_bassUpdateFlag, 0x1);
1734 HAL_AUDIO_WriteMaskByte(M2S_MBOX_SNDEFF_EN, 1<< (M2S_MBOX_COEFFUPDATE_EN_BIT), 0x00); //disable oefficient update
1735 }
1736 else
1737 {
1738 DBG_SOUND(printf("!!! undefined coefficient type ! ! !\n");)
1739 return;
1740 }
1741
1742 DBG_SOUND(printf("HAL a0 = %x", (MS_U8)(peq_coef->a0>>16)));
1743 DBG_SOUND(printf(" %x", (MS_U8)(peq_coef->a0>>8)));
1744 DBG_SOUND(printf(" %x\r\n", (MS_U8)peq_coef->a0));
1745
1746 DBG_SOUND(printf("HAL a1 = %x", (MS_U8)(peq_coef->a1>>16)));
1747 DBG_SOUND(printf(" %x", (MS_U8)(peq_coef->a1>>8)));
1748 DBG_SOUND(printf(" %x\r\n", (MS_U8)peq_coef->a1));
1749
1750 DBG_SOUND(printf("HAL a2 = %x", (MS_U8)(peq_coef->a2>>16)));
1751 DBG_SOUND(printf(" %x", (MS_U8)(peq_coef->a2>>8)));
1752 DBG_SOUND(printf(" %x\r\n", (MS_U8)peq_coef->a2));
1753
1754 DBG_SOUND(printf("HAL b1 = %x", (MS_U8)(peq_coef->b1>>16)));
1755 DBG_SOUND(printf(" %x", (MS_U8)(peq_coef->b1>>8)));
1756 DBG_SOUND(printf(" %x\r\n", (MS_U8)peq_coef->b1));
1757
1758 DBG_SOUND(printf("HAL b2 = %x", (MS_U8)(peq_coef->b2>>16)));
1759 DBG_SOUND(printf(" %x", (MS_U8)(peq_coef->b2>>8)));
1760 DBG_SOUND(printf(" %x\r\n", (MS_U8)peq_coef->b2));
1761 }
1762
1763 ////////////////////////////////////////////////////////////////////////////////
1764 /// @brief \b Function \b Name: HAL_SOUND_EnablePEQ()
1765 /// @brief \b Function \b Description: This routine is used to eable PEQ.
1766 /// @param <IN> \b Enpeq
1767 /// @param <OUT> \b NONE :
1768 /// @param <RET> \b NONE :
1769 /// @param <GLOBAL> \b NONE
1770 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnablePEQ(MS_BOOL Enpeq)1771 void HAL_SOUND_EnablePEQ(MS_BOOL Enpeq)
1772 {
1773 if(Enpeq)
1774 {
1775 HAL_AUDIO_WriteMaskByte(0x2D20, 0x01, 0x01);
1776 }
1777 else
1778 {
1779 HAL_AUDIO_WriteMaskByte(0x2D20, 0x01, 0x00);
1780 }
1781 }
1782
1783
1784 ////////////////////////////////////////////////////////////////////////////////
1785 /// @brief \b Function \b Name: HAL_SOUND_GetPEQ_Status()
1786 /// @brief \b Function \b Description: This routine is used to get the PEQ is enable or not
1787 /// @param <IN> \b NONE :
1788 /// @param <OUT> \b NONE :
1789 /// @param <RET> \b bEnable : TRUE --Enable PEQ
1790 /// FALSE--Disable PEQ
1791 /// @param <GLOBAL> \b NONE :
1792 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_GetPEQ_Status(void)1793 MS_U16 HAL_SOUND_GetPEQ_Status(void)
1794 {
1795 if((HAL_AUDIO_ReadByte(0x2D20)&0x01) == 0x01)
1796 {
1797 return 1;
1798 }else
1799 {
1800 return 0;
1801 }
1802 }
1803
1804 ////////////////////////////////////////////////////////////////////////////////
1805 /// @brief \b Function \b Name: HAL_SOUND_EnableDcRemove()
1806 /// @brief \b Function \b Description: This routine is used to eable DC remove.
1807 /// @param <IN> \b EnDcRemove
1808 /// @param <OUT> \b NONE :
1809 /// @param <RET> \b NONE :
1810 /// @param <GLOBAL> \b NONE
1811 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_EnableDcRemove(MS_BOOL EnDcRemove)1812 MS_BOOL HAL_SOUND_EnableDcRemove(MS_BOOL EnDcRemove)
1813 {
1814 if(EnDcRemove)
1815 {
1816 HAL_AUDIO_WriteMaskByte(0x2D20, 0x08, 0x08);
1817 }
1818 else
1819 {
1820 HAL_AUDIO_WriteMaskByte(0x2D20, 0x08, 0x00);
1821 }
1822 return 1;
1823 }
1824
1825 ////////////////////////////////////////////////////////////////////////////////
1826 /// @brief \b Function \b Name: MDrv_SOUND_SetMixModeVolume() @@VVV
1827 /// @brief \b Function \b Description: This routine is used to set the absolute volume of mix mode.
1828 /// @param <IN> \b eSourceType: for audio source
1829 /// @param <IN> \b VolType : for vol type
1830 /// @param <IN> \b u8u8Vol1 : MSB 7-bit register u8Value of 10-bit volume
1831 /// range from 0x00 to 0x7E , gain: +12db to -114db (-1 db per step)
1832 /// @param <IN> \b u8u8Vol2 : LSB 3-bit register u8Value of 10-bit volume
1833 /// range from 0x00 to 0x07 , gain: -0db to -0.875db (-0.125 db per step)
1834 /// @param <OUT> \b NONE :
1835 /// @param <RET> \b NONE :
1836 /// @param <GLOBAL> \b NONE :
1837 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetMixModeVolume(AUDIO_SOURCE_INFO_TYPE eSourceType,AUDIO_MIX_VOL_TYPE VolType,MS_U8 u8Vol1,MS_U8 u8Vol2)1838 void HAL_SOUND_SetMixModeVolume(AUDIO_SOURCE_INFO_TYPE eSourceType, AUDIO_MIX_VOL_TYPE VolType, MS_U8 u8Vol1, MS_U8 u8Vol2 )
1839 {
1840 switch (eSourceType)
1841 {
1842 case E_AUDIO_INFO_KTV_IN:
1843 switch(VolType)
1844 {
1845 case PCM_VOL:
1846 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_DMA_IN, u8Vol1, u8Vol2);
1847 break;
1848
1849 case MIC_VOL:
1850 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_MAIN, u8Vol1, u8Vol2);
1851 break;
1852
1853 case MP3_VOL:
1854 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_SECONDARY, u8Vol1, u8Vol2);
1855 break;
1856
1857 case ECHO1_VOL:
1858 if(u8Vol1<14)
1859 u8Vol1 = 14;
1860 HAL_AUDIO_WriteMaskByte(0x2D57, 0x7F, u8Vol1);
1861 HAL_AUDIO_WriteMaskByte(0x2D56, 0xE0, (u8Vol2<<5));
1862 break;
1863
1864 case ECHO2_VOL:
1865 HAL_AUDIO_WriteMaskByte(0x2D59, 0x7F, u8Vol1);
1866 HAL_AUDIO_WriteMaskByte(0x2D58, 0xE0, (u8Vol2<<5));
1867 break;
1868
1869 default:
1870 break;
1871 }
1872 break;
1873
1874 case E_AUDIO_INFO_GAME_IN:
1875 switch(VolType)
1876 {
1877 case PCM_VOL:
1878 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_DMA_IN, u8Vol1, u8Vol2);
1879 break;
1880
1881 case GAME1_VOL:
1882 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_MAIN, u8Vol1, u8Vol2);
1883 break;
1884
1885 case GAME2_VOL:
1886 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_SECONDARY, u8Vol1, u8Vol2);
1887 break;
1888 default:
1889 break;
1890 }
1891 break;
1892
1893 default:
1894 break;
1895 }
1896 }
1897
1898 ////////////////////////////////////////////////////////////////////////////////
1899 /// @brief \b Function \b Name: HAL_SOUND_SetMixModeMute() @@VVV
1900 /// @brief \b Function \b Description: This routine is used to set audio mix mode S/W mute.
1901 /// @param <IN> \b eSourseType: for audio source type
1902 /// @param <IN> \b VolType : for vol type
1903 /// @param <IN> \b bEnable : TRUE --Mute
1904 /// : FALSE--Unmute
1905 /// @param <OUT> \b NONE :
1906 /// @param <RET> \b NONE :
1907 /// @param <GLOBAL> \b NONE :
1908 ////////////////////////////////////////////////////////////////////////////////
HAL_SOUND_SetMixModeMute(AUDIO_SOURCE_INFO_TYPE eSourceType,AUDIO_MIX_VOL_TYPE VolType,MS_BOOL EnMute)1909 void HAL_SOUND_SetMixModeMute(AUDIO_SOURCE_INFO_TYPE eSourceType, AUDIO_MIX_VOL_TYPE VolType, MS_BOOL EnMute )
1910 {
1911 switch (eSourceType)
1912 {
1913 case E_AUDIO_INFO_KTV_IN:
1914 switch(VolType)
1915 {
1916 case PCM_VOL:
1917 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_DMA_IN, EnMute);
1918 break;
1919
1920 case MIC_VOL:
1921 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_MAIN, EnMute);
1922 break;
1923
1924 case MP3_VOL:
1925 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_SECONDARY, EnMute);
1926 break;
1927
1928 default:
1929 break;
1930 }
1931 break;
1932
1933 case E_AUDIO_INFO_GAME_IN:
1934 switch(VolType)
1935 {
1936 case PCM_VOL:
1937 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_DMA_IN, EnMute);
1938 break;
1939
1940 case GAME1_VOL:
1941 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_MAIN, EnMute);
1942 break;
1943
1944 case GAME2_VOL:
1945 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_SECONDARY, EnMute);
1946 break;
1947
1948 default:
1949 break;
1950 }
1951 break;
1952
1953 default:
1954 break;
1955 }
1956 }
1957
1958 //******************************************************************************
1959 /// @brief \b Function \b Name: HAL_SOUND_SetParam()
1960 /// @brief \b Function \b Description: This routine is used for adjust Common Sound parameters
1961 /// @return MS_BOOL \b : True / False
1962 //******************************************************************************
HAL_SOUND_SetParam(Sound_SET_Type Type,MS_U32 * p_param)1963 MS_BOOL HAL_SOUND_SetParam( Sound_SET_Type Type, MS_U32 *p_param )
1964 {
1965 MS_U8 param1 = (MS_U8)(p_param[0]);
1966 MS_U8 param2 = (MS_U8)(p_param[1]);
1967 MS_U8 param3 = (MS_U8)(p_param[2]);
1968 MS_U8 param4 = (MS_U8)(p_param[3]);
1969
1970 switch(Type)
1971 {
1972 case Sound_SET_Type_SetPreScale:
1973 HAL_SOUND_SetPreScale(param1, param2);
1974 break;
1975
1976 case Sound_SET_Type_SetMute:
1977 HAL_SOUND_SetMute(param1, param2);
1978 break;
1979
1980 case Sound_SET_Type_SetBalance:
1981 HAL_SOUND_SetBalance(param1);
1982 break;
1983
1984 case Sound_SET_Type_EnableEQ:
1985 HAL_SOUND_EnableEQ(param1);
1986 break;
1987
1988 case Sound_SET_Type_EnablePEQ:
1989 HAL_SOUND_EnablePEQ(param1);
1990 break;
1991
1992 case Sound_SET_Type_EnableTone:
1993 HAL_SOUND_EnableTone(param1);
1994 break;
1995
1996 case Sound_SET_Type_EnableAutoVolume:
1997 HAL_SOUND_EnableAutoVolume(param1);
1998 break;
1999
2000 case Sound_SET_Type_EnableSurround:
2001 HAL_SOUND_EnableSurround(param1);
2002 break;
2003
2004 case Sound_SET_Type_SetBass:
2005 HAL_SOUND_SetBass(param1);
2006 break;
2007
2008 case Sound_SET_Type_EnableBalance:
2009 HAL_SOUND_EnableBalance(param1);
2010 break;
2011
2012 case Sound_SET_Type_AbsoluteBass:
2013 HAL_SOUND_AbsoluteBass(param1);
2014 break;
2015
2016 case Sound_SET_Type_SetTreble:
2017 HAL_SOUND_SetTreble(param1);
2018 break;
2019
2020 case Sound_SET_Type_SetEq:
2021 HAL_SOUND_SetEq(param1, param2);
2022 break;
2023
2024 case Sound_SET_Type_SetEq_7band:
2025 HAL_SOUND_SetEq7(param1, param2);
2026 break;
2027
2028 case Sound_SET_Type_SetAvc:
2029 HAL_SOUND_SetAVCThreshold(param1);
2030 HAL_SOUND_SetAvcMode(param2);
2031 HAL_SOUND_SetAvcAT(param3);
2032 HAL_SOUND_SetAvcRT(param4);
2033 break;
2034
2035 case Sound_SET_Type_SetAudioDelay:
2036 HAL_SOUND_SetCH1AudioDelay(param1);
2037 break;
2038
2039 case Sound_SET_Type_SetSurround:
2040 HAL_SOUND_SetSurroundXA(param1);
2041 HAL_SOUND_SetSurroundXB(param2);
2042 HAL_SOUND_SetSurroundXK(param3);
2043 HAL_SOUND_SetSurroundLPFGain(param4);
2044 break;
2045
2046 case Sound_SET_Type_ConvertVolumeUnit:
2047 break;
2048
2049 case Sound_SET_Type_SetDCOffet:
2050 HAL_AUDIO_WriteByte(0x2B50 ,param1);
2051 HAL_AUDIO_WriteByte(0x2B51 ,param2);
2052 break;
2053
2054 case Sound_SET_Type_EnableSineTone:
2055 default:
2056 break;
2057 }
2058 return TRUE;
2059 }
2060
2061 //******************************************************************************
2062 /// @brief \b Function \b Name: HAL_SND_ProcessEnable()
2063 /// @brief \b Function \b Description: This routine is used for adjust Common Sound parameters
2064 //******************************************************************************
HAL_SND_ProcessEnable(Sound_ENABLE_Type Type,MS_BOOL enable)2065 MS_BOOL HAL_SND_ProcessEnable(Sound_ENABLE_Type Type, MS_BOOL enable)
2066 {
2067 MS_BOOL status = FALSE;
2068
2069 switch(Type)
2070 {
2071 case Sound_ENABL_Type_EQ:
2072 HAL_SOUND_EnableEQ(enable);
2073 status = TRUE;
2074 break;
2075
2076 case Sound_ENABL_Type_PEQ:
2077 HAL_SOUND_EnablePEQ(enable);
2078 status = TRUE;
2079 break;
2080
2081 case Sound_ENABL_Type_Tone:
2082 HAL_SOUND_EnableTone(enable);
2083 status = TRUE;
2084 break;
2085
2086 case Sound_ENABL_Type_AutoVolume:
2087 HAL_SOUND_EnableAutoVolume(enable);
2088 status = TRUE;
2089 break;
2090
2091 case Sound_ENABL_Type_Surround:
2092 HAL_SOUND_EnableSurround(enable);
2093 status = TRUE;
2094 break;
2095
2096 case Sound_ENABL_Type_Balance:
2097 HAL_SOUND_EnableBalance(enable);
2098 status = TRUE;
2099 break;
2100
2101 case Sound_ENABL_Type_DRC:
2102 HAL_SOUND_EnableDRC(enable);
2103 status = TRUE;
2104 break;
2105
2106 case Sound_ENABL_Type_KTVEcho:
2107 HAL_SOUND_EnableKTVEcho(enable);
2108 status = TRUE;
2109 break;
2110
2111 case Sound_ENABL_Type_EaseVol:
2112 HAL_SOUND_EnableEaseVol(enable);
2113 status = TRUE;
2114 break;
2115
2116 default:
2117 status = FALSE;
2118 break;
2119 }
2120 return(status);
2121 }
2122
2123
2124 //******************************************************************************
2125 /// @brief \b Function \b Name: HAL_SND_SetParam()
2126 /// @brief \b Function \b Description: This routine is used for adjust Common Sound parameters
2127 /// @return MS_BOOL \b : True / False
2128 //******************************************************************************
HAL_SND_SetParam(Sound_SET_PARAM_Type Type,MS_U16 param1,MS_U16 param2)2129 MS_BOOL HAL_SND_SetParam(Sound_SET_PARAM_Type Type, MS_U16 param1, MS_U16 param2)
2130 {
2131 MS_BOOL status = FALSE;
2132 MS_U16 data = 0;
2133
2134 switch(Type)
2135 {
2136 case Sound_SET_PARAM_PreScale:
2137 HAL_SOUND_SetPreScale(param1, param2); //param1: path, param2:prescale
2138 status = TRUE;
2139 break;
2140
2141 case Sound_SET_PARAM_Balance:
2142 HAL_SOUND_SetBalance(param1); // 0~100
2143 status = TRUE;
2144 break;
2145
2146 case Sound_SET_PARAM_EQ:
2147 HAL_SOUND_SetEq(param1, param2); //param1: band 0~4, param2:level 0~100
2148 break;
2149
2150 case Sound_SET_PARAM_Surround_XA:
2151 HAL_SOUND_SetSurroundXA(param1);
2152 status = TRUE;
2153 break;
2154
2155 case Sound_SET_PARAM_Surround_XB:
2156 HAL_SOUND_SetSurroundXB(param1);
2157 status = TRUE;
2158 break;
2159
2160 case Sound_SET_PARAM_Surround_XK:
2161 HAL_SOUND_SetSurroundXK(param1);
2162 status = TRUE;
2163 break;
2164
2165 case Sound_SET_PARAM_Surround_LPFGAIN:
2166 HAL_SOUND_SetSurroundLPFGain(param1);
2167 status = TRUE;
2168 break;
2169
2170 case Sound_SET_PARAM_Treble:
2171 HAL_SOUND_SetTreble(param1);
2172 status = TRUE;
2173 break;
2174
2175 case Sound_SET_PARAM_Bass:
2176 HAL_SOUND_SetBass(param1);
2177 status = TRUE;
2178 break;
2179
2180 case Sound_SET_PARAM_AbsoluteBass:
2181 HAL_SOUND_AbsoluteBass(param1);
2182 status = TRUE;
2183 break;
2184
2185 case Sound_SET_PARAM_Avc_Mode:
2186 HAL_SOUND_SetAvcMode(param1);
2187 status = TRUE;
2188 break;
2189
2190 case Sound_SET_PARAM_NR_Threshold:
2191 HAL_AUDIO_WriteByte(0x2D32, (MS_U8) param1);
2192 status = TRUE;
2193 break;
2194
2195 case Sound_SET_PARAM_Avc_Threshold:
2196 HAL_SOUND_SetAVCThreshold(param1);
2197 status = TRUE;
2198 break;
2199
2200 case Sound_SET_PARAM_Avc_AT:
2201 HAL_SOUND_SetAvcAT(param1);
2202 status = TRUE;
2203 break;
2204
2205 case Sound_SET_PARAM_Avc_RT:
2206 HAL_SOUND_SetAvcRT(param1);
2207 status = TRUE;
2208 break;
2209
2210 case Sound_SET_PARAM_AudioDelay:
2211 HAL_SOUND_SetCH1AudioDelay(param1);
2212 status = TRUE;
2213 break;
2214
2215 case Sound_SET_PARAM_DCOffet:
2216 HAL_AUDIO_WriteByte(0x2B51, param1);
2217 HAL_AUDIO_WriteByte(0x2B50, param2);
2218 status = TRUE;
2219 break;
2220
2221 case Sound_SET_PARAM_PEQ_48K_A0:
2222 if((param1>>8) > MAX_PEQ_BAND-1)
2223 printf("PEQ paramater Band should be 0~4\n");
2224 else
2225 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peq48KCoeffAddr+(param1>>8)*5, ((param1&0xFF)<<16)+param2);
2226 break;
2227
2228 case Sound_SET_PARAM_PEQ_48K_A1:
2229 if((param1>>8) > MAX_PEQ_BAND-1)
2230 printf("PEQ paramater Band should be 0~4\n");
2231 else
2232 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peq48KCoeffAddr+(param1>>8)*5+1, ((param1&0xFF)<<16)+param2);
2233 break;
2234
2235 case Sound_SET_PARAM_PEQ_48K_A2:
2236 if((param1>>8) > MAX_PEQ_BAND-1)
2237 printf("PEQ paramater Band should be 0~4\n");
2238 else
2239 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peq48KCoeffAddr+(param1>>8)*5+2, ((param1&0xFF)<<16)+param2);
2240 break;
2241
2242 case Sound_SET_PARAM_PEQ_48K_B1:
2243 if((param1>>8) > MAX_PEQ_BAND-1)
2244 printf("PEQ paramater Band should be 0~4\n");
2245 else
2246 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peq48KCoeffAddr+(param1>>8)*5+3, ((param1&0xFF)<<16)+param2);
2247 break;
2248
2249 case Sound_SET_PARAM_PEQ_48K_B2:
2250 if((param1>>8) > MAX_PEQ_BAND-1)
2251 printf("PEQ paramater Band should be 0~4\n");
2252 else
2253 HAL_MAD2_Write_DSP_Xbox(DSP2XboxAddr_peq48KCoeffAddr+(param1>>8)*5+4, ((param1&0xFF)<<16)+param2);
2254 break;
2255
2256 case Sound_SET_PARAM_PEQ_32K_A0:
2257 // No support 32K PEQ in T12
2258 break;
2259
2260 case Sound_SET_PARAM_PEQ_32K_A1:
2261 // No support 32K PEQ in T12
2262 break;
2263
2264 case Sound_SET_PARAM_PEQ_32K_A2:
2265 // No support 32K PEQ in T12
2266 break;
2267
2268 case Sound_SET_PARAM_PEQ_32K_B1:
2269 // No support 32K PEQ in T12
2270 break;
2271
2272 case Sound_SET_PARAM_PEQ_32K_B2:
2273 // No support 32K PEQ in T12
2274 break;
2275
2276 case Sound_SET_PARAM_AbsoluteEQ:
2277 if(param1 > 4)
2278 printf("GEQ Band should be 0~4\n");
2279 else
2280 {
2281 HAL_AUDIO_WriteByte(REG_SOUND_EQ1 + (param1*2), (MS_U8)param2);
2282 }
2283 break;
2284
2285 case Sound_SET_PARAM_Drc_Threshold:
2286 HAL_SOUND_SetDRCThreshold(param1);
2287 status = TRUE;
2288 break;
2289
2290 case Sound_SET_PARAM_DMAReader:
2291 if(param1 == 0)
2292 {
2293 if(param2 >= 4)
2294 {
2295 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_DMA_IN, true);
2296 }
2297 else
2298 {
2299 data = 0x0C + param2*4;
2300 HAL_SOUND_AbsoluteVolume(AUDIO_T3_PATH_MIXER_DMA_IN,data,0);
2301 HAL_SOUND_SetMute(AUDIO_T3_PATH_MIXER_DMA_IN, false);
2302 }
2303 status = TRUE;
2304 }
2305 break;
2306
2307 case Sound_SET_PARAM_Ease_Type_A:
2308 case Sound_SET_PARAM_Ease_Type_B:
2309 {
2310 MS_U32 u32EaseType = AUDIO_EASE_TYPE_LINEAR;
2311 MS_U32 u32DspPmEaseBase = 0;
2312
2313 status = TRUE;
2314
2315 switch (Type)
2316 {
2317 case Sound_SET_PARAM_Ease_Type_A:
2318 {
2319 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2320 break;
2321 }
2322
2323 case Sound_SET_PARAM_Ease_Type_B:
2324 default:
2325 {
2326 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2327 break;
2328 }
2329 }
2330
2331 switch (param1)
2332 {
2333 case E_AUDIO_EASE_TYPE_LINEAR:
2334 {
2335 u32EaseType = AUDIO_EASE_TYPE_LINEAR;
2336 break;
2337 }
2338
2339 case E_AUDIO_EASE_TYPE_INCUBIC:
2340 {
2341 u32EaseType = AUDIO_EASE_TYPE_INCUBIC;
2342 break;
2343 }
2344
2345 case E_AUDIO_EASE_TYPE_OUTCUBIC:
2346 {
2347 u32EaseType = AUDIO_EASE_TYPE_OUTCUBIC;
2348 break;
2349 }
2350
2351 case E_AUDIO_EASE_TYPE_INOUTCUBIC:
2352 {
2353 u32EaseType = AUDIO_EASE_TYPE_INOUTCUBIC;
2354 break;
2355 }
2356
2357 default:
2358 {
2359 HALSOUND_ERROR("%s: invalid audio ease type %d\n", __FUNCTION__, param1);
2360 status = FALSE;
2361 break;
2362 }
2363 }
2364
2365 if (status == TRUE)
2366 {
2367 HAL_MAD2_Write_DSP_Xbox((u32DspPmEaseBase + 2), u32EaseType);
2368 }
2369
2370 break;
2371 }
2372
2373 case Sound_SET_PARAM_Ease_Duration_A:
2374 case Sound_SET_PARAM_Ease_Duration_B:
2375 {
2376 MS_U32 u32MiniSecond = 0;
2377 MS_U32 u32SamplesOfMiniSecond = 0;
2378 MS_U32 u32DspPmEaseBase = 0;
2379
2380 status = TRUE;
2381
2382 switch (Type)
2383 {
2384 case Sound_SET_PARAM_Ease_Duration_A:
2385 {
2386 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2387 break;
2388 }
2389
2390 case Sound_SET_PARAM_Ease_Duration_B:
2391 {
2392 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2393 break;
2394 }
2395
2396 default:
2397 {
2398 HALSOUND_ERROR("%s: invalid audio ease command %d\n", __FUNCTION__, Type);
2399 status = FALSE;
2400 break;
2401 }
2402 }
2403
2404 if (status == TRUE)
2405 {
2406 if (param1 > 60000)
2407 {
2408 HALSOUND_ERROR("%s: target duration (%d) of audio ease is too large!\n", __FUNCTION__, param1);
2409 u32MiniSecond = 60000;
2410 }
2411 else
2412 {
2413 u32MiniSecond = (MS_U32)param1;
2414 }
2415
2416 u32SamplesOfMiniSecond = u32MiniSecond * 48; /* samples of 1 ms in 48KHz */
2417
2418 HAL_MAD2_Write_DSP_Xbox((u32DspPmEaseBase + 1), u32SamplesOfMiniSecond);
2419 }
2420
2421 break;
2422 }
2423
2424 case Sound_SET_PARAM_Ease_Gain_A:
2425 case Sound_SET_PARAM_Ease_Gain_B:
2426 {
2427 MS_U32 u32Gain = 0;
2428 MS_U32 u32DspPmEaseBase = 0;
2429 MS_U32 u32DspPmUpdateFlag = 0;
2430
2431 status = TRUE;
2432
2433 switch (Type)
2434 {
2435 case Sound_SET_PARAM_Ease_Gain_A:
2436 {
2437 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2438 u32DspPmUpdateFlag = DSP2XboxAddr_easeAUpdateFlag;
2439 break;
2440 }
2441
2442 case Sound_SET_PARAM_Ease_Gain_B:
2443 {
2444 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2445 u32DspPmUpdateFlag = DSP2XboxAddr_easeBUpdateFlag;
2446 break;
2447 }
2448
2449 default:
2450 {
2451 HALSOUND_ERROR("%s: invalid audio ease command %d\n", __FUNCTION__, Type);
2452 status = FALSE;
2453 break;
2454 }
2455 }
2456
2457 if (status == TRUE)
2458 {
2459 u32Gain = (MS_U32)(((param1 & 0xFF) << 16) | (param2 & 0xFFFF));
2460 if (u32Gain > 0x7FFFFF)
2461 {
2462 HALSOUND_ERROR("%s: target gain (0x%X) of audio ease is too large!\n", __FUNCTION__, (unsigned int)u32Gain);
2463 u32Gain = 0x7FFFFF;
2464 }
2465 HAL_MAD2_Write_DSP_Xbox(u32DspPmEaseBase, u32Gain);
2466
2467 /* trigger Audio Ease to apply current settings, this call should only be here! */
2468 HAL_MAD2_Write_DSP_Xbox(u32DspPmUpdateFlag, 0x1);
2469 }
2470
2471 break;
2472 }
2473
2474 case Sound_SET_PARAM_Ease_Target_Channel_A:
2475 case Sound_SET_PARAM_Ease_Target_Channel_B:
2476 {
2477 MS_U32 u32Mask = 0x000000;
2478 MS_U32 u32TargetChannel = AUDIO_EASE_CH_NONE;
2479 MS_U32 u32ChannelSetting = 0;
2480 MS_U32 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 8;
2481
2482 status = TRUE;
2483
2484 if (param2 == TRUE)
2485 {
2486 switch (Type)
2487 {
2488 case Sound_SET_PARAM_Ease_Target_Channel_A:
2489 {
2490 u32TargetChannel = AUDIO_EASE_CH_A;
2491 break;
2492 }
2493
2494 case Sound_SET_PARAM_Ease_Target_Channel_B:
2495 default:
2496 {
2497 u32TargetChannel = AUDIO_EASE_CH_B;
2498 break;
2499 }
2500 }
2501 }
2502 else
2503 {
2504 u32TargetChannel = AUDIO_EASE_CH_NONE;
2505 }
2506
2507 switch (param1)
2508 {
2509 case AUDIO_PATH_4:
2510 {
2511 /* for Channel 5 */
2512 u32Mask = 0x000F;
2513 break;
2514 }
2515
2516 case AUDIO_PATH_5:
2517 {
2518 /* for Channel 6 */
2519 u32Mask = 0x0000F0;
2520 u32TargetChannel <<= 4;
2521 break;
2522 }
2523
2524 case AUDIO_PATH_6:
2525 {
2526 /* for Channel 7 */
2527 u32Mask = 0x000F00;
2528 u32TargetChannel <<= 8;
2529 break;
2530 }
2531
2532 case AUDIO_PATH_7:
2533 {
2534 /* for Channel 8 */
2535 u32Mask = 0x00F000;
2536 u32TargetChannel <<= 12;
2537 break;
2538 }
2539
2540 case AUDIO_PATH_0:
2541 {
2542 /* for Channel 1~4 (Multi-Channel) */
2543 u32Mask = 0x0F0000;
2544 u32TargetChannel <<= 16;
2545 break;
2546 }
2547
2548 default:
2549 {
2550 HALSOUND_ERROR("%s: invalid audio ease path %d\n", __FUNCTION__, param1);
2551 status = FALSE;
2552 break;
2553 }
2554 }
2555
2556 if (status == TRUE)
2557 {
2558 u32ChannelSetting = HAL_MAD2_Read_DSP_Xbox(u32DspPmEaseBase);
2559 u32ChannelSetting = (u32ChannelSetting & (~u32Mask)) | u32TargetChannel;
2560 HAL_MAD2_Write_DSP_Xbox(u32DspPmEaseBase, u32ChannelSetting);
2561 }
2562
2563 break;
2564 }
2565
2566 default:
2567 status = FALSE;
2568 break;
2569 }
2570 return(status);
2571 }
2572
2573
2574
2575 //******************************************************************************
2576 /// @brief \b Function \b Name: HAL_AUDIO_SOUND_SetParam()
2577 /// @brief \b Function \b Description: This routine is used for adjust Common Sound parameters
2578 /// @return MS_BOOL \b : True / False
2579 //******************************************************************************
HAL_SND_GetParam(Sound_GET_PARAM_Type Type,MS_U16 param1)2580 MS_U16 HAL_SND_GetParam( Sound_GET_PARAM_Type Type, MS_U16 param1)
2581 {
2582 MS_U16 tmp=0;
2583 switch(Type)
2584 {
2585 case Sound_GET_PARAM_PreScale:
2586 tmp = HAL_SOUND_GetPreScale(param1); //param1: path
2587 break;
2588
2589 case Sound_GET_PARAM_Balance_L:
2590 tmp = HAL_SOUND_GetBalance_L(); // 0~0xFF
2591 break;
2592
2593 case Sound_GET_PARAM_Balance_R:
2594 tmp = HAL_SOUND_GetBalance_R(); // 0~0xFF
2595 break;
2596
2597 case Sound_GET_PARAM_EQ:
2598 tmp = HAL_SOUND_GetEq(param1); //param1: band 0~4
2599 break;
2600
2601 case Sound_GET_PARAM_Surround_XA:
2602 tmp = HAL_SOUND_GetSurroundXA();
2603 break;
2604
2605 case Sound_GET_PARAM_Surround_XB:
2606 tmp = HAL_SOUND_GetSurroundXB();
2607 break;
2608
2609 case Sound_GET_PARAM_Surround_XK:
2610 tmp = HAL_SOUND_GetSurroundXK();
2611 break;
2612
2613 case Sound_GET_PARAM_Surround_LPFGAIN:
2614 tmp = HAL_SOUND_GetSurroundLPFGain();
2615 break;
2616
2617 case Sound_GET_PARAM_Treble:
2618 tmp = HAL_SOUND_GetTreble();
2619 break;
2620
2621 case Sound_GET_PARAM_Bass:
2622 tmp = HAL_SOUND_GetBass();
2623 break;
2624
2625 case Sound_GET_PARAM_Avc_Mode:
2626 tmp = HAL_SOUND_GetAvcMode();
2627 break;
2628
2629 case Sound_GET_PARAM_Avc_Threshold:
2630 tmp = HAL_SOUND_GetAVCThreshold();
2631 break;
2632
2633 case Sound_GET_PARAM_Avc_AT:
2634 tmp = HAL_SOUND_GetAvcAT();
2635 break;
2636
2637 case Sound_GET_PARAM_Avc_RT:
2638 tmp = HAL_SOUND_GetAvcRT();
2639 break;
2640
2641 case Sound_GET_PARAM_AudioDelay:
2642 tmp = HAL_SOUND_GetCH1AudioDelay();
2643 break;
2644
2645 case Sound_GET_PARAM_DCOffet:
2646 tmp = HAL_AUDIO_ReadByte(0x2B51);
2647 tmp = ((MS_U16)HAL_AUDIO_ReadByte(0x2B50) |(tmp<<8));
2648 break;
2649
2650 case Sound_GET_PARAM_NR_Threshold:
2651 tmp = HAL_AUDIO_ReadByte(0x2D24);
2652 break;
2653
2654 case Sound_GET_PARAM_NR_Status:
2655 // tmp = (HAL_AUDIO_ReadByte(0x2A78) & 0x01);
2656 break;
2657
2658 case Sound_GET_PARAM_getSignal_Energy:
2659 // tmp = HAL_MAD_Read_DSP_sram(0x3F2B, DSP_MEM_TYPE_DM);
2660 break;
2661
2662 case Sound_GET_PARAM_EQ_Status:
2663 tmp = HAL_SOUND_GetEQ_Status();
2664 break;
2665
2666 case Sound_GET_PARAM_PEQ_Status:
2667 tmp = HAL_SOUND_GetPEQ_Status();
2668 break;
2669
2670 case Sound_GET_PARAM_Tone_Status:
2671 tmp = HAL_SOUND_GetTone_Status();
2672 break;
2673
2674 case Sound_GET_PARAM_AutoVolume_Status:
2675 tmp = HAL_SOUND_GetAutoVolume_Status();
2676 break;
2677
2678 case Sound_GET_PARAM_Surround_Status:
2679 tmp = HAL_SOUND_GetSurround_Status();
2680 break;
2681
2682 case Sound_GET_PARAM_DMAReader_Buffer_Addr:
2683 tmp = (MS_U16)(DMA_READER_TEMP_BUFFER_ADDR>>8);
2684 break;
2685
2686 case Sound_GET_PARAM_Ease_Type_A:
2687 case Sound_GET_PARAM_Ease_Type_B:
2688 {
2689 MS_U32 u32EaseType = AUDIO_EASE_TYPE_LINEAR;
2690 MS_U32 u32DspPmEaseBase = 0;
2691
2692 switch (Type)
2693 {
2694 case Sound_GET_PARAM_Ease_Type_A:
2695 {
2696 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2697 break;
2698 }
2699
2700 case Sound_GET_PARAM_Ease_Type_B:
2701 default:
2702 {
2703 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2704 break;
2705 }
2706 }
2707
2708 u32EaseType = HAL_MAD2_Read_DSP_Xbox((u32DspPmEaseBase + 2));
2709
2710 switch (u32EaseType)
2711 {
2712 case AUDIO_EASE_TYPE_LINEAR:
2713 {
2714 tmp = E_AUDIO_EASE_TYPE_LINEAR;
2715 break;
2716 }
2717
2718 case AUDIO_EASE_TYPE_INCUBIC:
2719 {
2720 tmp = E_AUDIO_EASE_TYPE_INCUBIC;
2721 break;
2722 }
2723
2724 case AUDIO_EASE_TYPE_OUTCUBIC:
2725 {
2726 tmp = E_AUDIO_EASE_TYPE_OUTCUBIC;
2727 break;
2728 }
2729
2730 case AUDIO_EASE_TYPE_INOUTCUBIC:
2731 {
2732 tmp = E_AUDIO_EASE_TYPE_INOUTCUBIC;
2733 break;
2734 }
2735
2736 default:
2737 {
2738 HALSOUND_ERROR("%s: invalid audio ease type %u\n", __FUNCTION__, (unsigned int)u32EaseType);
2739 break;
2740 }
2741 }
2742
2743 break;
2744 }
2745
2746 case Sound_GET_PARAM_Ease_Duration_A:
2747 case Sound_GET_PARAM_Ease_Duration_B:
2748 {
2749 MS_U32 u32MiniSecond = 0;
2750 MS_U32 u32DspPmEaseBase = 0;
2751
2752 switch (Type)
2753 {
2754 case Sound_GET_PARAM_Ease_Duration_A:
2755 {
2756 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2757 break;
2758 }
2759
2760 case Sound_GET_PARAM_Ease_Duration_B:
2761 {
2762 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2763 break;
2764 }
2765
2766 default:
2767 {
2768 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2769 break;
2770 }
2771 }
2772
2773 u32MiniSecond = HAL_MAD2_Read_DSP_Xbox((u32DspPmEaseBase + 1)) / 48;
2774 tmp = (MS_U16)u32MiniSecond;
2775
2776 break;
2777 }
2778
2779 case Sound_GET_PARAM_Ease_Gain_A:
2780 case Sound_GET_PARAM_Ease_Gain_B:
2781 {
2782 MS_U32 u32Value;
2783 MS_U32 u32DspPmEaseBase = 0;
2784
2785 switch (Type)
2786 {
2787 case Sound_GET_PARAM_Ease_Gain_A:
2788 {
2789 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr;
2790 break;
2791 }
2792
2793 case Sound_GET_PARAM_Ease_Gain_B:
2794 default:
2795 {
2796 u32DspPmEaseBase = DSP2XboxAddr_VolEaseAddr + 4;
2797 break;
2798 }
2799 }
2800
2801 u32Value = HAL_MAD2_Read_DSP_Xbox((u32DspPmEaseBase + 3));
2802 tmp = (MS_U16)(u32Value >> 8);
2803
2804 break;
2805 }
2806
2807 default:
2808 break;
2809 }
2810 return tmp;
2811
2812 }
2813
2814