source: svn/trunk/zas_dstar/devices/Audio/MSPH/MSPH.c @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
File size: 24.0 KB
Line 
1/*
2        Micronas MSPH Driver
3
4*/
5
6#include <stdio.h>
7
8//#include "typedef.h"
9#include "dsthalcommon.h"
10#include "MSPH.h"
11#include "dsthalsys.h"
12//#include "debug.h"
13short standard_select = 0;
14short modus_reg                         = 0;
15short i2s_config                        = 0;
16short i2s5_spdif                        =       0;
17
18static short dc_level = DEFAUL_DC_LEVEL;
19static int bCarrierMute = 0;
20
21DS_U8 MSP_Read(unsigned char address, unsigned short reg_address, short *data){
22        int result;
23        unsigned char buf[2];
24        short t_data = 0;
25        if(address != 0){       // dsp, demodulator register
26                result = DHL_SYS_MSPRead(address+1,reg_address,2,buf);
27        }else{
28                result = DHL_SYS_I2cReadEx(1,0x80,1,address,buf,2);
29        }
30
31        t_data |= buf[0] << 8;
32        t_data |= (0x00ff & buf[1]);
33
34        *data = t_data;
35
36        if ( result < 0 )
37                printf("Audio I2C Read Error\n");
38       
39        return result;
40}
41
42DS_U8 MSP_Write(unsigned char address, unsigned short reg_address, short value){
43        int result;
44        unsigned char buf[2] = {0};
45        if(address != 0){
46                result = DHL_SYS_MSPWrite(address,reg_address,2,value);
47        }else{
48                buf[0] = (unsigned char)(value>>8);
49                buf[1] = (unsigned char)(value&0xff);
50                result = DHL_SYS_I2cWriteEx(1,0x80,1,address,buf,2);
51        }
52       
53        if( result < 0){
54                printf("Audio I2C Write Error\n");
55                return 1;
56        }
57        return 0;
58}
59
60AUD_RESULT MSP_SPDIF_ON_OFF(DS_BOOL enable)
61{
62        AUD_RESULT result = AUD_NO_ERROR;
63
64        if(enable){
65                MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,0x1020);
66                // SPDIF Path ¹Ù²Ü ¶§ µðÄÚ´õ¿¡¼­ preamble ¸ÂÁö ¾ÊÀ» ¶§ Noise ¹ß»ýµÊ.
67                // µû¶ó¼­ MuteÀÏ ¶§ ¾Æ¿¹ SPDIF ½ÅÈ£¸¦ off ÇÏ¿© µðÄÚ´õ Ãø¿¡¼­ ¸®¼ÂÀ» Çϵµ·Ï...
68                // µðÄÚ´õ°¡ ´Ù½Ã ½ÃÀÛÇϹǷΠ¼Ò¸®°¡ ´Ê°Ô ³ª¿È.
69                MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,0x0400|0x0800);
70//              value |= 1 << 10;
71        }else{
72                MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,0x0000|0x0800);
73                MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,0x1220);
74        }
75       
76//      MSP_Write(MSP_DEMOD_ADDRESS,MSP_SPDIF_CONF,value);
77       
78        return result;
79}
80
81AUD_RESULT MSP_Mute(DS_BOOL enable)
82{
83        AUD_RESULT result = AUD_NO_ERROR;
84        short value;
85        if(enable){
86                MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
87                value |= FAST_MUTE;
88                MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
89                OS_mDelay(MSP_MUTE_DELAY);      // muteÇÒ °æ¿ì ÃÖ¼Ò 80m delay¸¦ ÁÖ°Ô µÊ.
90                MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
91                if((value & FAST_MUTE) != FAST_MUTE){
92                        result = AUD_ERROR_COMMUNICATION;
93                        return result;
94                }
95        }else{
96                printf("Not Support\n");
97        }
98        // MSP ÀÇ °æ¿ì º°µµ·Î UnmuteÇÒ ¼ö ¾øÀ½À¸·Î ÀÌ´Â »óÀ§¿¡¼­ ¿ø·¡ volumeÀ¸·Î º¯°æ.
99        // mute´Â fast mute command·Î.
100        //
101        return result;
102}
103static int n_SRS = 0;
104AUD_RESULT MSP_VolumeSet(int inDB)
105{
106        AUD_RESULT result = AUD_NO_ERROR;
107        short value;
108
109        if((inDB > 12 ) || (inDB < -114)){
110                printf("out of range\n");
111                return AUD_ERROR_BAD_PARAM;
112        }
113       
114        inDB = inDB + 114;      // 0 db¸¦ ¼³Á¤Çϱâ À§Çؼ­ 0x72°ªÀ» writingÇÑ´Ù.
115        if(n_SRS == 1){
116                inDB += 2;
117                if(inDB > 0x7f){
118                        inDB = 0x7f;
119                }
120        }
121        MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
122       
123        value = value & ~VOLUME_MASK;
124
125        value = value | (inDB << 8);
126       
127        MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
128        value = 0;
129        MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
130        value = ((value & VOLUME_MASK)>>8);
131        if(value != inDB){
132                printf("error\n");
133                return AUD_ERROR_COMMUNICATION;
134        }
135        return result;
136}
137
138AUD_RESULT MSP_BalanceSet(char Percentage)
139{
140        AUD_RESULT result = AUD_NO_ERROR;
141        short value;
142        short new_value;
143
144        if((Percentage < -100) || (Percentage > 100)){
145                printf("invalid parameter\n");
146                return AUD_ERROR_BAD_PARAM;
147        }
148
149
150        if(Percentage == 100){
151                Percentage = 127;
152        }else if(Percentage == -100){
153                Percentage = -127;
154        }else{
155                Percentage = (Percentage*128)/100;
156        }       
157       
158
159       
160        new_value = (Percentage);
161
162        new_value = new_value << 8;
163
164       
165        MSP_Read(MSP_DSP_ADDRESS,MSP_BALANCE,&value);
166       
167        value = value & ~BALANCE_MASK;
168
169        value = value | (new_value);
170
171        MSP_Write(MSP_DSP_ADDRESS,MSP_BALANCE,value);
172        MSP_Read(MSP_DSP_ADDRESS,MSP_BALANCE,&value);
173       
174        value = value & BALANCE_MASK;
175        if(value != new_value){
176                printf("error\n");
177                return AUD_ERROR_COMMUNICATION;
178        }
179        return result;
180}
181
182
183AUD_RESULT MSP_AudioDelayPath(AUD_SOURCE src)
184{
185        AUD_RESULT result = AUD_NO_ERROR;
186        short value = 0;
187        short temp = 0;
188       
189       
190        MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&value);       
191       
192        value &= 0x00ff;
193       
194        value |= (src << 8);
195       
196        MSP_Write(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,value);
197       
198        MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&temp);
199       
200        if(value != temp){
201                printf("Error\n");
202                return AUD_ERROR_COMMUNICATION;
203        }
204       
205        return result;
206}
207AUD_RESULT MSP_AudioDelaySet(unsigned int Delay)
208{
209        AUD_RESULT result = AUD_NO_ERROR;
210        short value = 0;
211        short temp = 0;
212       
213        if(Delay > 120){
214                printf("BAD Param\n");
215                return AUD_ERROR_BAD_PARAM;
216        }
217       
218        MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&value);       
219       
220        value &= 0xff00;
221       
222        value |= Delay & 0xff;
223       
224        MSP_Write(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,value);
225       
226        MSP_Read(MSP_DSP_ADDRESS,MSP_AUDIO_DELAY,&temp);
227       
228        if(value != temp){
229                printf("Error\n");
230                return AUD_ERROR_COMMUNICATION;
231        }
232       
233        return result;
234}
235
236AUD_RESULT MSP_SetScartToDSP(int num)
237{
238        AUD_RESULT result = AUD_NO_ERROR;
239        short value = 0;
240        short temp = 0;
241       
242        MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&value);
243       
244        value &= ~(0x1ff << 5);
245       
246        switch(num){
247                case 1:
248                        break;
249                case 2:
250                        value |= (0x10 << 5);
251                        break;
252                case 3:
253                        value |= (0x18 << 5);
254                        break;
255                case 4:
256                        value |= (0x1 << 5);
257                        break;         
258                case 5:
259                        value |= (0x8 << 5);
260                        break;         
261                default :
262                        printf("Bad Param\n");
263                        return AUD_ERROR_BAD_PARAM;
264                        break;
265        }
266       
267        MSP_Write(MSP_DSP_ADDRESS,MSP_ACB_REG,value);
268        MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&temp);
269       
270        if(value != temp){
271                printf("Error\n");
272                return AUD_ERROR_COMMUNICATION;
273        }
274       
275        return result;
276}
277
278AUD_RESULT MSP_SetI2S3Matrix(AUD_I2S_IN mode)
279{
280        AUD_RESULT result = AUD_NO_ERROR;
281        short value;
282        short temp;
283       
284        MSP_Read(MSP_DSP_ADDRESS,MSP_DOWNMIX,&value);
285        value &= 0xff00;
286        value |= mode;
287        MSP_Write(MSP_DSP_ADDRESS,MSP_DOWNMIX,value);
288        MSP_Read(MSP_DSP_ADDRESS,MSP_DOWNMIX,&temp);
289       
290        if(value != temp){
291                printf("Error\n");
292                return AUD_ERROR_COMMUNICATION;
293        }
294       
295        return result;
296}
297AUD_RESULT MSP_SetAudioMatrix(AUD_OUTPUT out,AUD_SOURCE src)
298{
299        AUD_RESULT result = AUD_NO_ERROR;
300        short value;
301        short temp;
302       
303        if((out >= AUD_OUT_MAX) || (src >= AUD_INPUT_MAX)){
304                printf("Bad Parameter\n");
305                return AUD_ERROR_BAD_PARAM;
306        }
307
308        //printf("out is %d , source is %d\n",out,src);
309        value = src << 8;
310       
311        value |= 0x20;
312       
313        if(out == AUD_MAIN_LR){
314                MSP_Write(MSP_DSP_ADDRESS,MSP_MAIN_SRC,value);
315                MSP_Read(MSP_DSP_ADDRESS,MSP_MAIN_SRC,&temp);
316        }else if ( out == AUD_SPDIF_OUTPUT){
317                MSP_Write(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,value);
318                MSP_Read(MSP_DSP_ADDRESS,MSP_SPDIF_SRC,&temp);
319        }else if ( out == AUD_SURROUND_PROCESSING_INPUT){
320                MSP_Write(MSP_DSP_ADDRESS,MSP_SURROUND_SRC,value);
321                MSP_Read(MSP_DSP_ADDRESS,MSP_SURROUND_SRC,&temp);
322    }else if ( out == AUD_I2S) {
323                MSP_Write(MSP_DSP_ADDRESS,MSP_I2S_SRC,value);
324                MSP_Read(MSP_DSP_ADDRESS,MSP_I2S_SRC,&temp);
325        }else{
326                printf("Not Implemented\n");
327                return AUD_ERROR_BAD_PARAM;
328        }
329       
330        if(value != temp){
331                printf("Error\n");
332                return AUD_ERROR_COMMUNICATION;
333        }
334       
335        return result;
336}
337
338AUD_RESULT MSP_SetI2SInputConfig(AUD_I2S_Config config)
339{
340        AUD_RESULT result = AUD_NO_ERROR;
341        short data = 0;
342       
343        if(config.align == RIGHT_ALIGN){
344                data |= (1 << 11 );     // 11bit align
345        }
346       
347        if( config.pol  == HIGH_LEFT ){
348                data |= (1 << 10);      // 10bit is strobe polarity
349        }
350       
351        if( config.delay == ONE_DELAY ){
352                data |= (1 << 9 );      // I2S Mode ( not left align mode )
353        }
354       
355        if( config.mode == SAMPLE_MULTI ){
356                data |= (1 << 8 ); // 7bit is sampling mode
357        }
358       
359        switch(config.bit_word){
360                case INPUT_16:
361                        data |= (7 << 4);
362                        break;
363                case INPUT_32:
364                default:
365                        data |= (0xf << 4);
366                        break;
367        }
368       
369        if( config.in_out == I2S_OUTPUT){
370                data |= (1 << 3 ); 
371        }
372       
373        data |= (1 << 2);       // all i2s input (1/2/3/4) use same configuration
374       
375        data |= 2;
376        i2s_config       = data;
377        printf("|%s| i2s_config=0x%x\n", __FUNCTION__, i2s_config);
378        //MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,i2s_config);
379       
380        return result;
381}
382
383AUD_RESULT MSP_GetI2SInputFrequency(unsigned int *freq)
384{
385        AUD_RESULT result = AUD_NO_ERROR;
386        return result;
387}
388
389AUD_RESULT MSP_SetI2SOutput(int bI2S)
390{
391    AUD_RESULT result = AUD_NO_ERROR;
392   
393    if ( bI2S ) {
394            modus_reg |= 0x40;      // I2S output - I2S format.
395            i2s_config &= ~3;
396            i2s_config |= 1;
397        } else {
398            modus_reg &= ~0x40;      // I2S output - I2S format.
399            i2s_config &= ~3;
400            i2s_config |= 2;
401        }
402       
403        return result;
404}
405
406AUD_RESULT MSP_SetAntiClipping(AUD_ANTICLIPPING_Mode mode)
407{
408        AUD_RESULT result = AUD_NO_ERROR;
409        short value;
410        if(mode > CLIPPING_WITH_DYNAMIC){
411                printf("Bad Parameter\n");
412                return AUD_ERROR_BAD_PARAM;
413        }
414       
415               
416        MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
417       
418        value = value & ~CLIPPING_MODE_MASK;
419
420        value = value | (mode);
421
422        MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
423        MSP_Read(MSP_DSP_ADDRESS,MSP_VOL,&value);
424       
425        value = value & CLIPPING_MODE_MASK;
426
427        if(value != mode){
428                printf("Error\n");
429                return AUD_ERROR_COMMUNICATION;
430        }
431
432        return result;
433}
434
435int MSP_ConfTest(int value)
436{
437                AUD_GPIO_Config config;
438                if(value){
439                        config.direction = GPIO_IN;
440                }else{
441                        config.direction = GPIO_OUT;
442                }
443               
444                MSP_PreConfigGPIO(config);     
445                return 1;
446}
447
448AUD_RESULT MSP_PreConfigGPIO(AUD_GPIO_Config config)
449{
450        AUD_RESULT result = AUD_NO_ERROR;
451       
452        if (config.direction == GPIO_IN){
453                modus_reg = modus_reg | 8;
454        }else{
455                modus_reg = modus_reg & ~8;
456        }
457        return result;
458}
459
460AUD_RESULT MSP_PresetAudioStandard(AUDIO_STANDARD std)
461{
462        AUD_RESULT result = AUD_NO_ERROR;
463       
464        modus_reg = modus_reg & ~0x6000;
465       
466        modus_reg |= (std << 13);
467       
468        return result;
469}
470
471AUD_RESULT MSP_PresetASS(DS_BOOL enable)
472{
473        AUD_RESULT result = AUD_NO_ERROR;
474       
475        if(enable){
476                modus_reg |= 1;
477        }else{
478                modus_reg &= ~1;
479        }
480       
481        return result; 
482} 
483
484AUD_RESULT MSP_SetGPIO(int num, int val)
485{
486        AUD_RESULT result = AUD_NO_ERROR;
487        short value = 0;
488        short temp = 0;
489       
490        if( (num != 0) && (num != 1) ){
491                printf("%d : BAD Param\n",__LINE__);
492                return AUD_ERROR_BAD_PARAM;
493        }
494       
495        if( (val != 0) && (val != 1)){
496                printf("%d : BAD Param\n",__LINE__);
497                return AUD_ERROR_BAD_PARAM;
498        }
499       
500//      MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,value);
501        MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&value);
502        if(val){
503                value |= (1<<(num+14));
504        }else{
505                value &= ~(1<<(num+14));
506        }
507       
508        MSP_Write(MSP_DSP_ADDRESS,MSP_ACB_REG,value);
509       
510        MSP_Read(MSP_DSP_ADDRESS,MSP_ACB_REG,&temp);
511       
512        if(value != temp){
513                printf("Error\n");
514                return AUD_ERROR_COMMUNICATION;
515        }
516       
517        return result;
518}
519
520AUD_RESULT MSP_GetChipInfo(unsigned short *info)
521{
522        AUD_RESULT result = AUD_NO_ERROR;
523        return result; 
524}
525
526AUD_RESULT MSP_PrintChipInfo(void)
527{
528        AUD_RESULT result = AUD_NO_ERROR;
529        short value = 0;
530        MSP_Read(MSP_DSP_ADDRESS,MSP_VENDOR,&value);
531       
532        if((value & 0xff00) == 0x0400){
533                printf("Hardware : MSP44/46xyK - D7\n");
534        }else if ((value & 0xff00 ) == 0x0500){
535                printf("Hardware : MSP44/46xyK - E8\n");
536        }else{
537                printf("Hardware : UNKNOWN\n");
538        }
539       
540        if((value & 0x00F0) == 0x0010){
541                printf("Familly Code : 40ms Delay\n");
542        }else if((value & 0x00F0) == 0x0010){
543                printf("Familly Code : 120ms Delay\n");
544        }else{
545                printf("Familly Code : UNKNOWN\n");
546        }
547       
548        if((value & 0xf) == 0xb){
549                printf("Revisino : MSP 44xyK/ MSP 46xyK - D7\n");
550        }else{
551                printf("Revision : UNKNOWN\n");
552        }
553       
554        MSP_Read(MSP_DSP_ADDRESS,MSP_PRODUCT,&value);
555       
556        printf("Product Code : ");
557        if((value & 0xff00) == 0x0){
558                printf("MSP 4400K / MSP 4600K - D7\n");
559        }else if((value & 0xff00) == 0x0a00){
560                printf("MSP 4410K / MSP 4610K - D7\n");
561        }else if((value & 0xff00) == 0x2800){
562                printf("MSP 4440K / MSP 4640K - D7\n");
563        }else if((value & 0xff00) == 0x3200){
564                printf("MSP 4450K / MSP 4650K - D7\n");
565        }else if((value & 0xff00) == 0x0100){
566                printf("MSP 4401K / MSP 4601K - D7\n");
567        }else if((value & 0xff00) == 0x0b00){
568                printf("MSP 4411K / MSP 4611K - D7\n");
569        }else if((value & 0xff00) == 0x2900){
570                printf("MSP 4441K / MSP 4641K - D7\n");
571        }else if((value & 0xff00) == 0x3300){
572                printf("MSP 4451K / MSP 4651K - D7\n");
573        }else if((value & 0xff00) == 0x0200){
574                printf("MSP 4402K / MSP 4602K - D7\n");
575        }else if((value & 0xff00) == 0x0c00){
576                printf("MSP 4412K / MSP 4612K - D7\n");
577        }else if((value & 0xff00) == 0x2a00){
578                printf("MSP 4442K / MSP 4642K - D7\n");
579        }else if((value & 0xff00) == 0x3400){
580                printf("MSP 4452K / MSP 4652K - D7\n");
581        }else {
582                printf("UNKNOWN\n");
583        }
584        printf("ROM Revision Code : ");
585        if((value & 0xff) == 0x67){
586                printf("MSP 44/46xyK - D7\n");
587        }else if((value & 0xff) == 0x67){
588                printf("MSP 44/46xyK - E8\n");
589        }else{
590                printf("UNKNOWN\n");
591        }
592       
593        return result; 
594}
595
596int MSP_GetGPIO(int num)
597{
598        short value;
599       
600        MSP_Read(MSP_DEMOD_ADDRESS,MSP_STATUS,&value);
601       
602        return ((value & (1<<(num+3))) ? 1 : 0);
603}
604
605AUD_RESULT MSP_SetDC(DS_BOOL enable)
606{
607        AUD_RESULT result = AUD_NO_ERROR;
608        short value = 0;
609        short  temp = 0;
610       
611        if(enable){
612               
613                value = dc_level | SRS_INPUT_MONO | SRS_FRONT_INPUT_PASSIVE_MATRIX;
614               
615                MSP_Write(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,value);
616                MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&temp);
617               
618                if(value != temp){
619                        printf("Error\n");
620                        return AUD_ERROR_COMMUNICATION;
621                }
622        }else{
623               
624                value = DC_OFF | SRS_INPUT_MONO | SRS_FRONT_INPUT_PASSIVE_MATRIX;
625               
626                MSP_Write(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,value);
627                MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&temp);
628               
629                if(value != temp){
630                        printf("Error\n");
631                        return AUD_ERROR_COMMUNICATION;
632                }       
633        }
634       
635       
636        return result;
637} 
638
639AUD_RESULT MSP_SetDCLevel(short val)
640{
641        AUD_RESULT result = AUD_NO_ERROR;
642        short value;
643       
644        if( val & ~0x7f ){
645                printf("Bad Param\n");
646                return AUD_ERROR_BAD_PARAM;
647        }
648       
649        val = val << 8;
650       
651        dc_level = val;
652       
653        MSP_Read(MSP_DSP_ADDRESS,MSP_XT_PROCESSING,&value);
654       
655        if(value & 0xff00){
656                MSP_SetDC(_TRUE_);
657        }
658       
659        return result;
660}       
661       
662       
663AUD_RESULT MSP_SetSRS(DS_BOOL enable)
664{
665        AUD_RESULT result = AUD_NO_ERROR;
666        short value;
667        short temp;
668       
669        if(enable){
670                value = 0x1070; // srs enable
671                n_SRS = 1;
672        }else{
673                value = 0x1000; // srs disable
674                n_SRS = 0;
675        }
676       
677        MSP_Write(MSP_DSP_ADDRESS,MSP_SRS_CONF,value);
678        MSP_Read(MSP_DSP_ADDRESS,MSP_SRS_CONF,&temp);
679       
680        if( value != temp){
681                printf("Error\n");
682                return AUD_ERROR_COMMUNICATION;
683        }
684       
685       
686        return result;
687}
688
689const short trubass[6][6] = 
690{
691        { 0x0602, 0x0400, 0x0600, 0x0, 0x0, 0x0 },
692        { 0x0602, 0x0400, 0x0600, 0x0, 0x0, 0x0 },
693        { 0x0902, 0x0600, 0x0900, 0x0, 0x0, 0x0 },
694        { 0x0f02, 0x0a00, 0x0f00, 0x0, 0x0, 0x0 },
695        { 0x1602, 0x0f00, 0x1600, 0x0, 0x0, 0x0 },
696        { 0x1e02, 0x1400, 0x1e00, 0x0, 0x0, 0x0 },
697};
698
699const short trubass_str[5] = {
700        0x0,
701        0x1200,
702        0x2500,
703        0x3800,
704        0x4b00,
705};
706
707AUD_RESULT MSP_SetTruBass(DS_BOOL enable,AUD_SPEAKER spk_size, int str)
708{
709        AUD_RESULT result = AUD_NO_ERROR;
710        short temp  = 0;
711        short value = 0;
712               
713        if(enable){
714               
715                value = trubass[spk_size][AUD_SUBW_FREQ];
716               
717                MSP_Write(MSP_DSP_ADDRESS,MSP_SUBWOOFER,value);
718                MSP_Read(MSP_DSP_ADDRESS,MSP_SUBWOOFER,&temp);
719               
720                if(value != temp ){
721                        printf("Error\n");
722                        return AUD_ERROR_COMMUNICATION;
723                }
724
725                value = trubass[spk_size][AUD_MP_HP];
726               
727                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_HIGH_PASS,value);
728                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_HIGH_PASS,&temp);
729               
730                if(value != temp ){
731                        printf("Error\n");
732                        return AUD_ERROR_COMMUNICATION;
733                }
734               
735                value = trubass[spk_size][AUD_MP_LP];
736               
737                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_LOW_PASS,value);
738                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_LOW_PASS,&temp);
739               
740                if(value != temp ){
741                        printf("Error\n");
742                        return AUD_ERROR_COMMUNICATION;
743                }
744               
745                value = trubass[spk_size][AUD_MB_LIM];
746               
747                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_AMP_LIMIT,value);
748                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_AMP_LIMIT,&temp);
749               
750                if(value != temp ){
751                        printf("Error\n");
752                        return AUD_ERROR_COMMUNICATION;
753                }
754
755                value = trubass[spk_size][AUD_MB_HMC];
756               
757                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_HMC,value);
758                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_HMC,&temp);
759               
760                if(value != temp ){
761                        printf("Error\n");
762                        return AUD_ERROR_COMMUNICATION;
763                }
764                               
765                value = trubass[spk_size][AUD_SUBW_LEVEL];
766               
767                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_WOOFER_LEV,value);
768                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_WOOFER_LEV,&temp);
769               
770                if(value != temp ){
771                        printf("Error\n");
772                        return AUD_ERROR_COMMUNICATION;
773                }
774               
775                value = trubass_str[str];
776               
777                MSP_Write(MSP_DSP_ADDRESS,MSP_MB_STR,value);
778                MSP_Read(MSP_DSP_ADDRESS,MSP_MB_STR,&temp);
779               
780                if(value != temp ){
781                        printf("Error\n");
782                        return AUD_ERROR_COMMUNICATION;
783                }               
784
785        }else{
786                value = CORNER_FREQ | MB_UNFILTER;
787               
788                MSP_Write(MSP_DSP_ADDRESS,MSP_SUBWOOFER,value);
789                MSP_Read(MSP_DSP_ADDRESS,MSP_SUBWOOFER,&temp);
790               
791                if(value != temp ){
792                        printf("Error\n");
793                        return AUD_ERROR_COMMUNICATION;
794                }
795        }       
796        return result;
797}
798
799AUD_RESULT MSP_ChangeTruBassLevel(short val)
800{
801        AUD_RESULT result = AUD_NO_ERROR;
802        short value;
803       
804        if( val & ~0x7f ){
805                printf("Bad Param\n");
806                return AUD_ERROR_BAD_PARAM;
807        }
808       
809        val = val << 8;
810       
811        MSP_Write(MSP_DSP_ADDRESS,MSP_MB_STR,val);
812       
813        MSP_Read(MSP_DSP_ADDRESS,MSP_MB_STR,&value);
814       
815        if( value != val ){
816                printf("Error\n");
817                return AUD_ERROR_COMMUNICATION;
818        }
819       
820        return result;
821}
822
823AUD_RESULT MSP_SetSVC(DS_BOOL enable)
824{
825        AUD_RESULT result = AUD_NO_ERROR;
826        short value;
827        short temp;
828       
829        MSP_Read(MSP_DSP_ADDRESS,MSP_AVC,&value);
830       
831        if( enable ){
832                value |= 0x8100;
833        }else{
834                value &= ~0x8000;
835        }
836       
837        MSP_Write(MSP_DSP_ADDRESS,MSP_AVC,value);
838       
839        MSP_Read(MSP_DSP_ADDRESS,MSP_AVC,&temp);
840       
841        if( temp != value ){
842                printf("Error\n");
843                return AUD_ERROR_COMMUNICATION;
844        }
845       
846        return result;
847}
848
849AUD_RESULT MSP_SetEQ(char trebledb, char bassdb)
850{
851        AUD_RESULT result = AUD_NO_ERROR;
852        short value = 0;
853        short t_value = 0;
854
855        if((trebledb > 20) || (trebledb < -12)){
856                printf("Bad Parameter\n");
857                return AUD_ERROR_BAD_PARAM;
858        }
859
860        if((bassdb > 20) || (bassdb < -12)){
861                printf("Bad Parameter\n");
862                return AUD_ERROR_BAD_PARAM;
863        }       
864       
865        if(bassdb < 13){
866                value = bassdb*8;
867        }else{
868                value = 12*8 + ((bassdb-12)*4);
869        }
870       
871        if(value >= 0x80){
872                value = 0x7f;
873        }
874        t_value = value << 8;
875       
876        MSP_Read(MSP_DSP_ADDRESS,MSP_BASS,&value);
877       
878        value = value & ~UPPER_BYTE_MASK;
879
880        value = value | (t_value);
881
882        MSP_Write(MSP_DSP_ADDRESS,MSP_BASS,value);
883        MSP_Read(MSP_DSP_ADDRESS,MSP_BASS,&value);
884       
885        value = value & UPPER_BYTE_MASK;
886       
887        if(value != (t_value)){
888                printf("Error\n");
889                return AUD_ERROR_COMMUNICATION;
890        }
891       
892        if(trebledb < 13){
893                trebledb = trebledb*8;
894        }else{
895                trebledb = 12*8 + ((trebledb-12)*4);
896        }
897
898        t_value = trebledb << 8;
899
900        MSP_Read(MSP_DSP_ADDRESS,MSP_TREBLE,&value);
901       
902        value = value & ~UPPER_BYTE_MASK;
903
904        value = value | (t_value);
905
906        MSP_Write(MSP_DSP_ADDRESS,MSP_TREBLE,value);
907        MSP_Read(MSP_DSP_ADDRESS,MSP_TREBLE,&value);
908       
909        value = value & UPPER_BYTE_MASK;
910       
911        if(value != t_value){
912                printf("Error\n");
913                return AUD_ERROR_COMMUNICATION;
914        }
915        return result;
916}
917
918AUD_RESULT MSP_GetBTSC(AUD_SAP *src)
919{
920        AUD_RESULT result = AUD_NO_ERROR;
921        short value;
922       
923        MSP_Read(MSP_DEMOD_ADDRESS,MSP_STATUS,&value);
924       
925        if( ( value & 0x6 ) == 0x6 ){
926                src->signal = 0;
927        }else{
928                src->signal = 1;
929        }
930        src->sap                        = ( value & ( 1 << 8 ) ) ? 1 : 0;
931        src->stereo             = ( value & ( 1 << 6 ) ) ? 1 : 0;
932       
933        return result;
934}
935
936AUD_RESULT MSP_SetI2SSync(DS_BOOL enable)
937{
938        AUD_RESULT result = AUD_NO_ERROR;
939        short value = 0;
940        short temp  = 0;
941       
942        MSP_Read(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,&value);
943       
944        if(enable){     // i2s3 to sync with 48khz
945                printf("value : 0x%x\n",value);
946                value &= ~0xff;
947                printf("value : 0x%x\n",value);
948                MSP_Write(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,value);
949                printf("value : 0x%x\n",value);
950        }else{                  //      i2s3 to async 6khz to 49khz
951        printf("value : 0x%x\n",value);
952                value |= 0x1;
953                MSP_Write(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,value);
954                printf("value : 0x%x\n",value);
955        }
956       
957        MSP_Read(MSP_DSP_ADDRESS,MSP_I2S3_PRESCALE,&temp);
958       
959        if(temp != value){
960                printf("Error\n");
961                return AUD_ERROR_COMMUNICATION;
962        }
963       
964        return result;
965}
966AUD_RESULT MSP_SetSoundForFM(AUD_SOUND_FOR_FM src)
967{
968        AUD_RESULT result = AUD_NO_ERROR;
969        short value = 0;
970        short temp = 0;
971       
972        MSP_Read(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,&value);
973       
974        value &= 0xff00;
975       
976        value |= src;
977       
978        MSP_Write(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,value);
979       
980        MSP_Read(MSP_DSP_ADDRESS,MSP_FM_AM_PRESCALE,&temp);
981       
982        if(value != temp){
983                printf("Error\n");
984                return AUD_ERROR_COMMUNICATION;
985        }
986               
987       
988        return result;
989}
990
991AUD_RESULT MSP_SetCarrierMute(DS_BOOL bEn)
992{
993        DS_U8 result=0;
994
995     bCarrierMute = bEn;
996     
997     //result = MSP_Write(MSP_DEMOD_ADDRESS, MSP_CARRIER_MUTE_THRESHOLD, bEn ? 0x2a : 0x7ff);
998     result = MSP_Write(MSP_DEMOD_ADDRESS, MSP_AD_CV, bEn ? 0x2D0 : 0xD0);
999     
1000     if ( result == 0 )
1001          return AUD_NO_ERROR;
1002     
1003     return AUD_ERROR_COMMUNICATION;
1004}
1005
1006AUD_RESULT MSP_SetPrescale(AUD_SOURCE src, short valuedb)
1007{
1008        AUD_RESULT result = AUD_NO_ERROR;
1009        short value = 0;
1010        short reg_ad = 0;
1011        short temp = 0;
1012       
1013        switch(src){
1014                case AUD_SCART:
1015                        reg_ad = MSP_SCART_PRESCALE;
1016                        break;
1017                case AUD_I2S_3_12:
1018                        reg_ad = MSP_I2S3_PRESCALE;
1019                        break;
1020                case AUD_FM_AM:
1021                        reg_ad = MSP_FM_AM_PRESCALE;
1022                        break;
1023                default:
1024                        printf("BAD Param\n");
1025                        return AUD_ERROR_BAD_PARAM;
1026                        break;
1027        }
1028       
1029       
1030        MSP_Read(MSP_DSP_ADDRESS,reg_ad,&value);
1031       
1032        value &= 0x00ff;
1033       
1034        value |= ( valuedb << 8 );
1035       
1036       
1037       
1038        MSP_Write(MSP_DSP_ADDRESS,reg_ad,value);
1039       
1040       
1041        MSP_Read(MSP_DSP_ADDRESS,reg_ad,&temp);
1042       
1043        if(value != temp){
1044                printf("Error\n");
1045                return AUD_ERROR_COMMUNICATION;
1046        }
1047       
1048        return result;
1049}
1050
1051AUD_RESULT MSP_DemodSet(AUD_AUDIO_STANDARD std)
1052{
1053        AUD_RESULT result = AUD_NO_ERROR;
1054       
1055        MSP_Write(MSP_DEMOD_ADDRESS,MSP_STANDARD_SEL,std);
1056        OS_mDelay(10);
1057        MSP_SetCarrierMute(bCarrierMute);
1058       
1059        return result;
1060}
1061
1062AUD_RESULT MSP_Start(void)
1063{
1064        AUD_RESULT result = AUD_NO_ERROR;
1065
1066        MSP_Write(0x12,0x35,0x600);     // overall gainÀ» ³ôÀÓ.
1067       
1068        MSP_Write(0x10,0x50,0x400);
1069       
1070        MSP_Write(MSP_DEMOD_ADDRESS,MSP_MODUS,modus_reg);
1071        MSP_SetCarrierMute(bCarrierMute);
1072       
1073        MSP_Write(MSP_DEMOD_ADDRESS,MSP_I2S_CONF,i2s_config);
1074       
1075        MSP_Write(MSP_DSP_ADDRESS,MSP_VOL,0);
1076       
1077        MSP_SPDIF_ON_OFF(1);
1078       
1079        return result;
1080        // software reset
1081}
1082
1083AUD_RESULT MSP_SetClippingThreshold(AUD_TH th)
1084{
1085        AUD_RESULT result = AUD_NO_ERROR;
1086        short value = 0;
1087        short temp = 0;
1088       
1089        if( th == AUD_TH_3DBFS ){
1090                value = 0x2d33;
1091        }else if( th == AUD_TH_2DBFS ){
1092                value = 0x2849;
1093        }else if( th == AUD_TH_1DBFS ){
1094                value = 0x23e7;
1095        }else if( th == AUD_TH_0DBFS ){
1096                value = 0x2000;
1097        }else if( th == AUD_TH_N1DBFS ){
1098                value = 0x1c85;
1099        }else if( th == AUD_TH_N2DBFS ){
1100                value = 0x1999;
1101        }else if( th == AUD_TH_N3DBFS ){
1102                value = 0x16a7;
1103        }else if( th == AUD_TH_N4DBFS ){
1104                value = 0x1430;
1105        }else if( th == AUD_TH_N5DBFS ){
1106                value = 0x11fe;
1107        }else if( th == AUD_TH_N6DBFS ){
1108                value = 0x1000;
1109        }else{
1110                printf("BAD Param\n");
1111                return AUD_ERROR_BAD_PARAM;
1112        }
1113       
1114        MSP_Write(MSP_DSP_ADDRESS, MSP_TH_FOR_CLIP , value );
1115        OS_mDelay(10);
1116        MSP_Read(MSP_DSP_ADDRESS,MSP_TH_FOR_CLIP, &temp );
1117       
1118        if( value != temp ){
1119                printf("Error : value : %x  temp : %x\n",value,temp);
1120                return AUD_ERROR_COMMUNICATION;
1121        }
1122       
1123        return result;
1124}
1125
1126AUD_RESULT MSP_Reset(void)
1127{
1128        AUD_RESULT result = AUD_NO_ERROR;
1129        DHL_RESULT dhlResult;
1130        int try = 0;
1131        short test = 0;
1132
1133        while(try < 5 ){
1134                MSP_Write(MSP_CONTROL_ADDRESS,MSP_RESET,0x8000);
1135                MSP_Read(MSP_CONTROL_ADDRESS,MSP_RESET,&test);
1136                OS_mDelay(10);
1137                MSP_Write(MSP_CONTROL_ADDRESS,MSP_RESET,0x0);
1138                MSP_Read(MSP_CONTROL_ADDRESS,MSP_RESET,&test);
1139                if(test != 0x0){
1140                        try++;
1141                        if(try == 5){
1142                                result = AUD_ERROR_COMMUNICATION;
1143                        }
1144           
1145                        dhlResult = DHL_SYS_SetGPIO(GPIO_AP_RESETN,0);
1146                        OS_mDelay(300);
1147                        dhlResult = DHL_SYS_SetGPIO(GPIO_AP_RESETN,1);
1148                        OS_mDelay(300);
1149           
1150                        if(dhlResult != DHL_OK){
1151                                printf("\n\n\nError In AP Reset with GPIO\n\n\n");
1152                                result = AUD_ERROR_COMMUNICATION;
1153                                goto done;
1154                        }
1155                }else{
1156                  break;
1157                }
1158               
1159        }
1160done:
1161        return result;
1162}
1163
1164int test(void)
1165{
1166        AUD_I2S_Config config;
1167        MSP_ConfTest(1);
1168        MSP_PresetAudioStandard(STANDARD_M_BTSC);
1169       
1170        config.align            = LEFT_ALIGN;
1171        config.pol                      = HIGH_LEFT;
1172        config.mode                     =       SAMPLE_2;
1173        config.delay            = ONE_DELAY;
1174        config.bit_word = INPUT_32;
1175        config.in_out           = I2S_INPUT;
1176       
1177        MSP_SetI2SInputConfig(config);
1178       
1179        printf("modus                   : 0x%x\n", modus_reg);
1180        printf("i2s_config      : 0x%x\n", i2s_config); 
1181
1182        MSP_Write(MSP_DEMOD_ADDRESS,MSP_MODUS,0);
1183       
1184        MSP_Write(MSP_DEMOD_ADDRESS,MSP_I2S_CONF,i2s_config);
1185       
1186        return 1;
1187}
1188
1189int red(void){
1190        short value = 0;
1191        MSP_Read(MSP_DSP_ADDRESS,MSP_TH_FOR_CLIP,&value);
1192        printf("value is 0x%x\n",value);
1193        return 0;
1194}
1195       
1196int getb(void)
1197{
1198        AUD_SAP test;
1199       
1200        test.sap = 0;
1201        test.stereo = 0;
1202       
1203        MSP_GetBTSC(&test);
1204        printf("%s\n",test.signal ? "SIGNAL AVAIL" : "SIGNAL NOT AVAIL");
1205        printf("%s%s\n",test.sap ? "SAP\n" : "", test.stereo ? "STEREO" : " MONO ");
1206       
1207        return 1;
1208       
1209}       
1210
1211int msp_w(short address, short subaddress, short value)
1212{
1213        MSP_Write(address,subaddress,value);
1214        return 1;
1215}
1216int msp_r(short address, short subaddress)
1217{
1218        short data = 0;
1219        MSP_Read(address,subaddress,&data);
1220        printf("%x[%x] : %x\n",address,subaddress,data);
1221        return 1;
1222}
Note: See TracBrowser for help on using the repository browser.